@rainbow-robotics/muscat-plugin-kit 0.1.2-dev.40 → 0.1.2-dev.42

package/cli/src/build.mjs

@@ -22,7 +22,7 @@ import { assertManifest, manifestRuntime } from "./manifest.mjs";
 // In node mode, use the current process.
 function findJsRuntime() {
   if (typeof Bun === "undefined") return { bin: process.execPath, isBun: false };
-  for (const c of ["bun", "node", "node20", "node18"]) {
+  for (const c of ["bun", "node", "nodejs"]) {
     if (hasBin(c)) return { bin: c, isBun: c === "bun" };
   }
   return null;
@@ -75,27 +75,33 @@ function isMainBranch() {
 // rclpy: arch-agnostic (pure Python) → dist/ros2_ws/install/ (built once)
 // rclcpp: arch-specific C++ binaries → dist/ros2_ws/install-{arch}/ per arch
 export async function exportRos2Build(root, archs = ["amd64", "arm64"]) {
-  if (manifestRuntime(root) !== "ros2") return;
+  if (manifestRuntime(root) !== "ros2") return [];
   const { assertDockerReady, ensureImage, colconBuild, ROS2_DEV_IMAGE, ARCH_DOCKER_PLATFORM } = await import("./ros2.mjs");
   try {
     assertDockerReady();
   } catch (e) {
     log.warn(`ros2 build skipped: ${e.message}`);
-    return;
+    return [];
   }
 
   const manifest = JSON.parse(readFileSync(resolve(root, "manifest.json"), "utf8"));
   const rosClient = manifest.runtime?.rosClient;
 
+  const skipped = [];
   if (rosClient === "rclcpp") {
     // C++ ROS2: compile per arch so each robot picks the right install-{arch}/
     for (const arch of archs) {
       const dockerPlatform = ARCH_DOCKER_PLATFORM[arch];
-      if (!dockerPlatform) { log.warn(`unknown arch '${arch}' — skipped`); continue; }
+      if (!dockerPlatform) { log.warn(`unknown arch '${arch}' — skipped`); skipped.push(arch); continue; }
       const archImage = `${ROS2_DEV_IMAGE}-${arch}`;
-      await ensureImage(archImage, { platform: dockerPlatform });
-      colconBuild(root, { symlink: false, arch });
-      log.ok(`dist/ros2_ws/install-${arch}/ ready`);
+      try {
+        await ensureImage(archImage, { platform: dockerPlatform });
+        colconBuild(root, { symlink: false, arch });
+        log.ok(`dist/ros2_ws/install-${arch}/ ready`);
+      } catch {
+        log.warn(`${arch} ros2 build skipped — QEMU not available`);
+        skipped.push(arch);
+      }
     }
   } else {
     // rclpy / pure Python: arch-agnostic, build once
@@ -103,6 +109,7 @@ export async function exportRos2Build(root, archs = ["amd64", "arm64"]) {
     colconBuild(root, { symlink: false });
     log.ok("dist/ros2_ws/install/ ready");
   }
+  return skipped;
 }
 
 // For cpp plugins, compile cpp/ inside the Ubuntu container (Release) per arch
@@ -110,13 +117,13 @@ export async function exportRos2Build(root, archs = ["amd64", "arm64"]) {
 // robot-compatible executables. rb-runtime prefers dist/{arch}/ and falls back
 // to dist/{entry} (legacy). Skipped (with a warning) if Docker is unavailable.
 export async function exportCppBuild(root, distDir, archs = ["amd64", "arm64"]) {
-  if (manifestRuntime(root) !== "cpp") return;
+  if (manifestRuntime(root) !== "cpp") return [];
   const { assertDockerReady, ensureImage, cmakeBuild, CPP_DEV_IMAGE, ARCH_DOCKER_PLATFORM } = await import("./cpp.mjs");
   try {
     assertDockerReady();
   } catch (e) {
     log.warn(`cpp build skipped: ${e.message}`);
-    return;
+    return [];
   }
 
   const entry = JSON.parse(readFileSync(resolve(root, "manifest.json"), "utf8")).runtime?.entry;
@@ -125,26 +132,31 @@ export async function exportCppBuild(root, distDir, archs = ["amd64", "arm64"])
     return;
   }
 
+  const skipped = [];
   for (const arch of archs) {
-    // python과 동일하게 arch별 이미지를 빌드해야 --platform 불일치를 피할 수 있다.
     const dockerPlatform = ARCH_DOCKER_PLATFORM[arch];
-    if (!dockerPlatform) { log.warn(`unknown arch '${arch}' — skipped`); continue; }
+    if (!dockerPlatform) { log.warn(`unknown arch '${arch}' — skipped`); skipped.push(arch); continue; }
     const archImage = `${CPP_DEV_IMAGE}-${arch}`;
-    await ensureImage(archImage, { platform: dockerPlatform });
-    cmakeBuild(root, { buildType: "Release", arch });
-    const buildDir = `cpp/build-${arch}`;
-    const built = resolve(root, buildDir, entry);
-    if (existsSync(built)) {
-      const archDir = resolve(distDir, arch);
-      mkdirSync(archDir, { recursive: true });
-      const dest = resolve(archDir, entry);
-      copyFileSync(built, dest);
-      chmodSync(dest, 0o755);
-      log.ok(`cpp binary → dist/${arch}/${entry}`);
-    } else {
-      log.warn(`cpp binary not found at ${buildDir}/${entry} — skipped for ${arch}`);
+    try {
+      await ensureImage(archImage, { platform: dockerPlatform });
+      cmakeBuild(root, { buildType: "Release", arch });
+      const built = resolve(root, `cpp/build-${arch}`, entry);
+      if (existsSync(built)) {
+        const archDir = resolve(distDir, arch);
+        mkdirSync(archDir, { recursive: true });
+        const dest = resolve(archDir, entry);
+        copyFileSync(built, dest);
+        chmodSync(dest, 0o755);
+        log.ok(`cpp binary → dist/${arch}/${entry}`);
+      } else {
+        log.warn(`cpp binary not found at cpp/build-${arch}/${entry}`);
+      }
+    } catch {
+      log.warn(`${arch} cpp build skipped — QEMU not available`);
+      skipped.push(arch);
     }
   }
+  return skipped;
 }
 
 const PRERELEASE_RE = /\.(dev|a|b|rc|alpha|beta)\d*/i;
@@ -245,10 +257,22 @@ export async function buildPlugin({ root, minify = false } = {}) {
   mkdirSync(distDir, { recursive: true });
 
   const manifest = JSON.parse(readFileSync(resolve(pluginRoot, "manifest.json"), "utf8"));
-  const contributesUi = (manifest.contributes ?? []).some((c) => c.ui);
   const uiDir = resolve(pluginRoot, "ui");
+  const declaredUiEntries = [...new Set(
+    (manifest.contributes ?? []).map((c) => c.ui).filter(Boolean)
+  )];
+  // Validate each declared UI entry has a matching source file
+  for (const entry of declaredUiEntries) {
+    const exists = [".tsx", ".ts", ".jsx", ".js"].some(
+      (ext) => existsSync(resolve(uiDir, entry + ext))
+    );
+    if (!exists)
+      throw new Error(
+        `contributes declares ui "${entry}" but ui/${entry}.tsx (or .ts/.jsx/.js) does not exist.`
+      );
+  }
   const hasUiFiles = existsSync(uiDir) && readdirSync(uiDir).some((f) => /\.[tj]sx?$/.test(f));
-  if (contributesUi || hasUiFiles) {
+  if (declaredUiEntries.length > 0 || hasUiFiles) {
     runViteBuild(pluginRoot, { mode: minify ? "production" : "development" });
   }
 
@@ -422,6 +446,8 @@ export async function runBuild(args) {
 
   const { pluginRoot, distDir } = await buildPlugin({ root, minify: true });
 
+  const skippedArches = { wheels: [], ros2: [], cpp: [] };
+
   // python / rclpy: lock + wheel vendor in Ubuntu 24.04 container
   if (!noLock) {
     const manifest = JSON.parse(readFileSync(resolve(root, "manifest.json"), "utf8")).runtime ?? {};
@@ -431,15 +457,29 @@ export async function runBuild(args) {
     if (needsLock) {
       const { lockAndVendor } = await import("./python.mjs");
       try {
-        await lockAndVendor(pluginRoot, archs);
+        skippedArches.wheels = await lockAndVendor(pluginRoot, archs);
       } catch (e) {
         log.warn(`python lock/vendor skipped: ${e.message}`);
+        skippedArches.wheels = archs;
       }
     }
   }
 
-  await exportRos2Build(root, archs);
-  await exportCppBuild(root, distDir, archs);
+  skippedArches.ros2 = await exportRos2Build(root, archs) ?? [];
+  skippedArches.cpp  = await exportCppBuild(root, distDir, archs) ?? [];
   calcInstalledSize(pluginRoot);
   if (!noZip) packZip(pluginRoot);
+
+  // Build summary
+  const allSkipped = [...new Set([...skippedArches.wheels, ...skippedArches.ros2, ...skippedArches.cpp])];
+  if (allSkipped.length > 0) {
+    const line = "─".repeat(58);
+    console.log(`\n${line}`);
+    log.warn(`Cross-arch builds skipped (QEMU not available): ${allSkipped.join(", ")}`);
+    if (skippedArches.wheels.length) log.warn(`  wheels:  ${skippedArches.wheels.join(", ")}`);
+    if (skippedArches.ros2.length)   log.warn(`  ros2:    ${skippedArches.ros2.join(", ")}`);
+    if (skippedArches.cpp.length)    log.warn(`  cpp:     ${skippedArches.cpp.join(", ")}`);
+    log.warn(`  Enable: docker run --privileged --rm tonistiigi/binfmt --install all`);
+    console.log(line);
+  }
 }

package/cli/src/devUi.mjs

@@ -7,7 +7,7 @@ import { copyFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
 import { SANDBOX_HTML } from "./build.mjs";
-import { checkKitUpdate, findPluginRoot, hasBin, kitRoot, log } from "./util.mjs";
+import { checkKitUpdate, findPluginRoot, hasBin, kitRoot, log, parseArgs, prompt } from "./util.mjs";
 
 const PREVIEW_PKG = "@rainbow-robotics/preview-host";
 const CACHE_DIR = resolve(homedir(), ".muscat-pk");
@@ -79,7 +79,7 @@ function findViteBin(pluginRoot) {
 
 // Spawn vite build --watch as a background process.
 // Returns the child process, or null if vite/node not available.
-function spawnViteWatch(pluginRoot, node) {
+function spawnViteWatch(pluginRoot, node, { robotIp = "" } = {}) {
   const viteBin = findViteBin(pluginRoot);
   if (!node || !viteBin || !existsSync(viteBin)) return null;
 
@@ -87,6 +87,7 @@ function spawnViteWatch(pluginRoot, node) {
   return spawn(node, [viteBin, "build", "--watch", "--mode", "development", "--outDir", DEV_OUT], {
     cwd: pluginRoot,
     stdio: "inherit",
+    env: { ...process.env, ...(robotIp ? { VITE_RRS_PY_HOST: robotIp } : {}) },
   });
 }
 
@@ -105,15 +106,18 @@ function waitForInitialBuild(distDir, timeoutMs = 30_000) {
 }
 
 export async function runDevUi(args = []) {
-  const portIdx = args.indexOf("--port");
-  const port = portIdx !== -1 ? args[portIdx + 1] : "4180";
+  const parsed = parseArgs(args);
+  const port = parsed.port ?? "4180";
+  const robotIp = parsed["robot-ip"] ?? await prompt("  Robot IP (Enter to skip): ");
 
   await checkKitUpdate();
   const pluginRoot = findPluginRoot();
   const outDir = stageDevAssets(pluginRoot);
 
+  if (robotIp) log.info(`MUSCAT_API_ORIGIN → http://${robotIp}:*`);
+
   const node = findNodeBin();
-  const viteProc = spawnViteWatch(pluginRoot, node);
+  const viteProc = spawnViteWatch(pluginRoot, node, { robotIp });
 
   if (viteProc) {
     log.step("waiting for initial vite build…");

package/cli/src/python.mjs

@@ -2,7 +2,7 @@
 // Used by dev:back (hot-reload) and build (lock + wheel vendor).
 import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
-import { dirname } from "node:path";
+import { dirname, resolve } from "node:path";
 import { hasBin, log, pruneMuskatImages, resolveDockerfile } from "./util.mjs";
 
 export const PYTHON_DEV_IMAGE = "muscat-pk-python-dev";
@@ -27,22 +27,30 @@ export async function ensureImage(image = PYTHON_DEV_IMAGE, { platform = null }
   pruneMuskatImages();
 }
 
-// Docker --platform 플래그: 컨테이너를 target arch로 띄우면
-// pip이 glibc + arch를 자동 감지해 올바른 휠을 받는다.
-const ARCH_DOCKER_PLATFORM = {
-  amd64: "linux/amd64",
-  arm64: "linux/arm64",
+// pip --platform does NOT auto-expand manylinux tags (unlike sys_tags()) — exact match only.
+// Specifying all common glibc milestones ensures packages built for any Ubuntu era are found.
+const PIP_PLATFORM = {
+  amd64: [
+    "manylinux_2_5_x86_64",
+    "manylinux_2_17_x86_64",
+    "manylinux_2_27_x86_64",
+    "manylinux_2_28_x86_64",
+    "manylinux_2_34_x86_64",
+    "manylinux_2_39_x86_64",
+    "linux_x86_64",
+  ],
+  arm64: [
+    "manylinux_2_17_aarch64",
+    "manylinux_2_27_aarch64",
+    "manylinux_2_28_aarch64",
+    "manylinux_2_34_aarch64",
+    "manylinux_2_39_aarch64",
+    "linux_aarch64",
+  ],
 };
 
-/**
- * Ubuntu 24.04 + py3.12 컨테이너 안에서:
- *   1. uv pip compile requirements.txt → dist/requirements.lock  (arch 무관, 1회)
- *   2. archs별 pip download --platform <manylinux_tag> → dist/wheels/  (네이티브 휠 벤더링)
- *
- * none-any 휠은 pip이 두 번째 arch에서 자동 skip → 중복 없음.
- * requirements.txt 없으면 조용히 건너뜀.
- */
-export async function lockAndVendor(pluginRoot, archs = ["x86_64", "aarch64"]) {
+export async function lockAndVendor(pluginRoot, archs = ["amd64", "arm64"]) {
+  // ponytail: pip --platform used intentionally (not QEMU) — downloads wheels without running target arch code.
   const reqTxt = resolve(pluginRoot, "requirements.txt");
   if (!existsSync(reqTxt)) {
     log.warn("requirements.txt not found — lock/vendor skipped");
@@ -66,45 +74,28 @@ export async function lockAndVendor(pluginRoot, archs = ["x86_64", "aarch64"]) {
   if (lockResult.status !== 0) throw new Error("lock generation failed (uv pip compile)");
   log.ok("dist/requirements.lock ready");
 
-  // arch별 휠 벤더링 — QEMU 불필요 (download only, --platform 고정)
-  // 한 arch가 실패해도 나머지 arch는 계속 시도한다.
   const failed = [];
   for (const arch of archs) {
-    const dockerPlatform = ARCH_DOCKER_PLATFORM[arch];
-    if (!dockerPlatform) {
-      log.warn(`unknown arch '${arch}' — skipped`);
-      continue;
-    }
-    // arch별 이미지 빌드 (--platform 지정) → pip이 glibc+arch 자동 감지 → 올바른 휠 선택.
-    const archImage = `${PYTHON_DEV_IMAGE}-${arch}`;
-    await ensureImage(archImage, { platform: dockerPlatform });
-
-    log.step(`vendoring wheels for ${arch} (${dockerPlatform})…`);
-    // 패키지별 개별 download로 private/미공개 패키지 실패 시에도 나머지 계속 진행.
-    const script = [
-      `set -e`,
-      `cd /plugin`,
-      `mkdir -p dist/wheels`,
-      `pkgs=$(grep -v '^#' dist/requirements.lock | grep -v '^[[:space:]]' | grep -v '^$')`,
-      `SKIP=""`,
-      `for pkg in $pkgs; do`,
-      `  pip3 download "$pkg" --no-deps --only-binary=:all: -d dist/wheels -q 2>&1 || SKIP="$SKIP $pkg"`,
-      `done`,
-      `[ -z "$SKIP" ] || echo "WARN: no wheel found (package not on PyPI or missing binary wheel):$SKIP"`,
-    ].join("\n");
+    const pipPlatforms = PIP_PLATFORM[arch];
+    if (!pipPlatforms) { log.warn(`unknown arch '${arch}' — skipped`); continue; }
+    log.step(`vendoring wheels for ${arch}…`);
     const r = spawnSync(
       "docker",
       [
         "run", "--rm",
-        "--platform", dockerPlatform,
+        "-e", "PIP_ROOT_USER_ACTION=ignore",
         "-v", `${pluginRoot}:/plugin`,
-        archImage,
-        "bash", "-c", script,
+        "-w", "/plugin",
+        PYTHON_DEV_IMAGE,
+        "bash", "-c",
+        "mkdir -p dist/wheels && pip3 download -r dist/requirements.lock --no-deps --only-binary=:all: -d dist/wheels -q " +
+          "--python-version 312 --implementation cp --abi cp312 " +
+          pipPlatforms.map((p) => `--platform ${p}`).join(" "),
       ],
       { stdio: "inherit" },
     );
     if (r.status !== 0) {
-      log.warn(`wheel vendoring failed for ${arch} — some packages may not have manylinux wheels`);
+      log.warn(`wheel vendoring failed for ${arch}`);
       failed.push(arch);
     } else {
       log.ok(`dist/wheels/ ready (${arch})`);
@@ -114,9 +105,5 @@ export async function lockAndVendor(pluginRoot, archs = ["x86_64", "aarch64"]) {
   if (failed.length === archs.length) {
     throw new Error(`wheel vendoring failed for all archs: ${failed.join(", ")}`);
   }
-  if (failed.length > 0) {
-    log.warn(`wheel vendoring partial — failed: ${failed.join(", ")}, ok: ${archs.filter((a) => !failed.includes(a)).join(", ")}`);
-  } else {
-    log.ok(`dist/wheels/ ready (${archs.join(", ")})`);
-  }
+  return failed;
 }

package/cli/src/templates-embedded.mjs

@@ -0,0 +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":"IiIiCk11c2NhdCBwbHVnaW4gYmFja2VuZCDigJQgX19QTFVHSU5fTkFNRV9fCgpSdW4gd2l0aDoKICBtdXNjYXQtcGsgZGV2OmJhY2sKICBweXRob24gbWFpbi5weQoKVGhpcyB0ZW1wbGF0ZSB1c2VzIHRoZSBoaWdoLWxldmVsIFJhaW5ib3cgUHl0aG9uIFNESyBpbnN0ZWFkIG9mIHdpcmluZyB0aGUKdHJhbnNwb3J0IGxheWVyIGRpcmVjdGx5LgoiIiIKCmltcG9ydCB0aW1lCmZyb20gdHlwaW5nIGltcG9ydCBBbnkKCmZyb20gcmFpbmJvdy5yYl9zZGsgaW1wb3J0IFJCTWFuaXB1bGF0ZVNESywgUkJQbHVnaW5DYWxsCgoKUExVR0lOX05BTUUgPSAiX19QTFVHSU5fTkFNRV9fIgoKcGx1Z2luID0gUkJQbHVnaW5DYWxsKCkKCgpAcGx1Z2luLnN1YnNjcmliZSgiZXZlbnQiKQpkZWYgb25fdWlfZXZlbnQocGF5bG9hZDogZGljdFtzdHIsIEFueV0gfCBOb25lID0gTm9uZSk6CiAgICAiIiJIYW5kbGUgbWVzc2FnZXMgcHVibGlzaGVkIGZyb20gdGhlIHBsdWdpbiBVSSB3aXRoIHJiLnB1YigiZXZlbnQiLCAuLi4pLiIiIgogICAgcHJpbnQoZiJbe1BMVUdJTl9OQU1FfV0gZXZlbnQ6IiwgcGF5bG9hZCkKCgpAcGx1Z2luLnNlcnZlKCJncmlwIikKZGVmIGdyaXAocGF5bG9hZDogZGljdFtzdHIsIEFueV0gfCBOb25lID0gTm9uZSk6CiAgICAiIiJIYW5kbGUgdGhlIGRlZmF1bHQgVUkgYnV0dG9uOiByYi5hY3Rpb24oImdyaXAiLCB7IHdpZHRoIH0pLiIiIgogICAgd2lkdGggPSAocGF5bG9hZCBvciB7fSkuZ2V0KCJ3aWR0aCIsIDIwKQogICAgcHJpbnQoZiJbe1BMVUdJTl9OQU1FfV0gZ3JpcCByZXF1ZXN0ZWQ6IHdpZHRoPXt3aWR0aH0iKQoKICAgIHBsdWdpbi5wdWJsaXNoKCJzdGF0ZSIsIHsicmVhZHkiOiBUcnVlLCAibGFzdF9ncmlwX3dpZHRoIjogd2lkdGh9KQogICAgcmV0dXJuIHsib2siOiBUcnVlLCAid2lkdGgiOiB3aWR0aH0KCgpAcGx1Z2luLnNlcnZlKCJ0b29sL2VjaG8iKQpkZWYgZWNobyhwYXlsb2FkOiBkaWN0W3N0ciwgQW55XSB8IE5vbmUgPSBOb25lKToKICAgICIiIlNtYWxsIHF1ZXJ5IGV4YW1wbGUgY2FsbGFibGUgZnJvbSB0aGUgVUkgd2l0aCByYi5hY3Rpb24oInRvb2wvZWNobyIsIC4uLikuIiIiCiAgICByZXR1cm4geyJlY2hvIjogcGF5bG9hZCwgInBsdWdpbiI6IFBMVUdJTl9OQU1FfQoKCmRlZiBwaW5nX3VpX2V4YW1wbGUoKToKICAgICIiIgogICAgRXhhbXBsZTogY2FsbCBhIHF1ZXJ5YWJsZSBzZXJ2ZWQgYnkgdGhlIFVJLgoKICAgIEluIHRoZSBmcm9udGVuZCwgcmVnaXN0ZXI6CiAgICAgIHJiLnNlcnZlKCJ0b29sL3BpbmciLCBhc3luYyAocGF5bG9hZCkgPT4gKHsgcG9uZzogcGF5bG9hZCB9KSkKICAgICIiIgogICAgcmVzID0gcGx1Z2luLmNhbGwoInRvb2wvcGluZyIsIHBheWxvYWQ9eyJoZWxsbyI6ICJwbHVnaW4ifSkKICAgIHByaW50KGYiW3tQTFVHSU5fTkFNRX1dIHBpbmcgcmVzcG9uc2U6IiwgcmVzKQogICAgcmV0dXJuIHJlcwoKCmRlZiBtb3ZlX2pfZXhhbXBsZSgpOgogICAgIiIiCiAgICBFeGFtcGxlOiB1c2Ugb3RoZXIgcm9ib3QgU0RLcyBmcm9tIHRoZSBzYW1lIGJhY2tlbmQuCgogICAgVGhpcyBmdW5jdGlvbiBpcyBub3QgY2FsbGVkIGF1dG9tYXRpY2FsbHkuIEFkZCBzYWZldHkgY2hlY2tzIGFuZCBjYWxsIGl0CiAgICBmcm9tIHlvdXIgb3duIGhhbmRsZXIgd2hlbiB0aGUgcm9ib3QgaXMgcmVhZHkuCiAgICAiIiIKICAgIG1hbmlwdWxhdGUgPSBSQk1hbmlwdWxhdGVTREsoKQoKICAgIHJldHVybiBtYW5pcHVsYXRlLm1vdmUuY2FsbF9tb3ZlX2ooCiAgICAgICAgcm9ib3RfbW9kZWw9IkM1MDA5MjAiLAogICAgICAgIHRhcmdldD17CiAgICAgICAgICAgICJ0YXJfdmFsdWVzIjogWzAsIDAsIDAsIDAsIDAsIDBdLAogICAgICAgICAgICAidGFyX2ZyYW1lIjogMCwKICAgICAgICAgICAgInRhcl91bml0IjogMCwKICAgICAgICB9LAogICAgKQoKCmRlZiBtYWluKCk6CiAgICBwbHVnaW4ucHVibGlzaCgic3RhdGUiLCB7InJlYWR5IjogVHJ1ZSwgInBsdWdpbiI6IFBMVUdJTl9OQU1FfSkKICAgIHByaW50KGYiW3tQTFVHSU5fTkFNRX1dIGJhY2tlbmQgcmVhZHkiKQoKICAgIHRyeToKICAgICAgICB3aGlsZSBUcnVlOgogICAgICAgICAgICB0aW1lLnNsZWVwKDEpCiAgICBleGNlcHQgS2V5Ym9hcmRJbnRlcnJ1cHQ6CiAgICAgICAgcHJpbnQoZiJbe1BMVUdJTl9OQU1FfV0gc3RvcHBlZCIpCgoKaWYgX19uYW1lX18gPT0gIl9fbWFpbl9fIjoKICAgIG1haW4oKQo=","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"};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rainbow-robotics/muscat-plugin-kit",
-  "version": "0.1.2-dev.40",
+  "version": "0.1.2-dev.42",
   "type": "module",
   "engines": {
     "node": ">=20"
@@ -31,7 +31,7 @@
     "@types/react-dom": "^19.0.4"
   },
   "dependencies": {
-    "@rainbow-robotics/preview-host": "0.1.2-dev.40",
+    "@rainbow-robotics/preview-host": "0.1.2-dev.42",
     "socket.io": "^4.8.1"
   },
   "optionalDependencies": {