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

package/cli/src/ros2.mjs

@@ -0,0 +1,90 @@
+// Shared ROS2 Docker helpers (Jazzy + Python 3.12 — matches the robot backend).
+// Used by dev:back (interactive dev loop) and build (export install/ into the ZIP).
+import { spawnSync } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { hasBin, log, pruneMuskatImages, resolveDockerfile } from "./util.mjs";
+
+export const ROS2_DEV_IMAGE = "muscat-pk-ros2-dev";
+
+/** First package directory under ros2_ws/src (the colcon package name). */
+export function ros2PackageName(root) {
+  const srcDir = resolve(root, "ros2_ws/src");
+  if (!existsSync(srcDir)) return null;
+  const dirs = readdirSync(srcDir, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name);
+  return dirs[0] ?? null;
+}
+
+export function assertDockerReady() {
+  if (!hasBin("docker")) {
+    throw new Error("Docker not found. ROS2 needs Docker (Jazzy + Python 3.12 container).");
+  }
+}
+
+export const ARCH_DOCKER_PLATFORM = {
+  amd64: "linux/amd64",
+  arm64: "linux/arm64",
+};
+
+/** Build the dev image from the kit's bundled Dockerfile (Docker layer-caches). */
+export async function ensureImage(image = ROS2_DEV_IMAGE, { platform = null } = {}) {
+  const dockerfile = await resolveDockerfile("Dockerfile.dev");
+  log.step(`docker build -t ${image}${platform ? ` (${platform})` : ""} (first run is slow, then cached)…`);
+  const platformFlags = platform ? ["--platform", platform] : [];
+  const r = spawnSync(
+    "docker",
+    ["build", ...platformFlags, "-t", image, "-f", dockerfile, dirname(dockerfile)],
+    { stdio: "inherit" },
+  );
+  if (r.status !== 0) throw new Error("docker build failed.");
+  pruneMuskatImages();
+}
+
+/**
+ * Run `colcon build` inside the container, producing ros2_ws/install on the host
+ * (the workspace is mounted). symlink=true for dev (fast, edit-in-place);
+ * symlink=false for export builds that ship in the ZIP (real copies, relocatable).
+ */
+/**
+ * arch=null → dev mode, builds to ros2_ws/install/ (native)
+ * arch="amd64"|"arm64" → export mode, builds to ros2_ws/install-{arch}/ using arch-specific image
+ */
+/**
+ * symlink=true (dev): ros2_ws/install/ — local dev workspace, not for ZIP
+ * symlink=false, arch=null (rclpy export): dist/ros2_ws/install/
+ * symlink=false, arch="amd64"|"arm64" (rclcpp export): dist/ros2_ws/install-{arch}/
+ */
+export function colconBuild(root, { image = ROS2_DEV_IMAGE, symlink = false, arch = null } = {}) {
+  // paths are relative to ros2_ws/ inside the container
+  let installBase;
+  if (symlink) {
+    installBase = "install";
+  } else if (arch) {
+    installBase = `../dist/ros2_ws/install-${arch}`;
+  } else {
+    installBase = "../dist/ros2_ws/install";
+  }
+  const flag = symlink ? "--symlink-install" : "";
+  const script = [
+    "pip install -r requirements.txt --break-system-packages --ignore-installed -q || true",
+    "cd ros2_ws",
+    // ponytail: rm only on cross-arch; same-arch dev rebuilds keep the cache
+    ...(arch ? ["rm -rf build"] : []),
+    `colcon build ${flag} --install-base ${installBase}`.trim(),
+  ].join(" && ");
+  const label = arch
+    ? `colcon build (${arch}) → dist/ros2_ws/install-${arch}/…`
+    : `colcon build${symlink ? " --symlink-install" : ""} (in container)…`;
+  log.step(label);
+  const actualImage = arch ? `${ROS2_DEV_IMAGE}-${arch}` : image;
+  const dockerPlatform = arch ? ARCH_DOCKER_PLATFORM[arch] : null;
+  const platformFlags = dockerPlatform ? ["--platform", dockerPlatform] : [];
+  const r = spawnSync(
+    "docker",
+    ["run", "--rm", ...platformFlags, "-e", "PIP_ROOT_USER_ACTION=ignore", "-v", `${root}:/plugin`, "-w", "/plugin", actualImage, "bash", "-lc", script],
+    { cwd: root, stdio: "inherit" },
+  );
+  if (r.status !== 0) throw new Error(`colcon build failed${arch ? ` (${arch})` : ""}.`);
+}

package/cli/src/socketBridge.mjs

@@ -0,0 +1,129 @@
+import { createServer } from "node:http";
+import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { Server } from "socket.io";
+
+// Self-contained logger — this module also runs standalone inside the bridge
+// Docker container, where ./util.mjs is not available.
+const log = {
+  step: (...m) => console.log("›", ...m),
+  warn: (...m) => console.warn("⚠", ...m),
+};
+
+const DEFAULT_ACTION_TIMEOUT_MS = 10_000;
+
+export function startSocketBridge({ port = 10000, host = "0.0.0.0" } = {}) {
+  const httpServer = createServer();
+  const io = new Server(httpServer, { cors: { origin: "*" } });
+
+  // topic → socketId (serve_register로 등록된 queryable)
+  const queryables = new Map();
+  // call_id → { timer, resolve } (action → serve_call → serve_reply 대기)
+  const pending = new Map();
+
+  function cleanupSocket(socket) {
+    for (const [topic, sid] of queryables) {
+      if (sid === socket.id) queryables.delete(topic);
+    }
+    for (const [id, p] of pending) {
+      if (p.sid !== socket.id) continue;
+      clearTimeout(p.timer);
+      p.resolve(undefined);
+      pending.delete(id);
+    }
+  }
+
+  io.on("connection", (socket) => {
+    socket.on("sub", async (data = {}) => {
+      if (!data.topic) return;
+      await socket.join(`t:${data.topic}`);
+    });
+
+    socket.on("unsub", async (data = {}) => {
+      if (!data.topic) return;
+      await socket.leave(`t:${data.topic}`);
+    });
+
+    socket.on("pub", (data = {}) => {
+      const { topic, payload } = data;
+      if (!topic) return;
+      io.to(`t:${topic}`).emit("msg", { topic, payload });
+    });
+
+    socket.on("serve_register", (data = {}) => {
+      if (!data.topic) return;
+      queryables.set(data.topic, socket.id);
+    });
+
+    socket.on("serve_unregister", (data = {}) => {
+      if (queryables.get(data.topic) === socket.id) queryables.delete(data.topic);
+    });
+
+    socket.on("serve_reply", (data = {}) => {
+      const p = pending.get(data.id);
+      if (!p) return;
+      clearTimeout(p.timer);
+      p.resolve(data.payload);
+      pending.delete(data.id);
+    });
+
+    socket.on("action", (data = {}, ack) => {
+      const { topic, payload } = data;
+      const targetSid = queryables.get(topic);
+      const target = targetSid && io.sockets.sockets.get(targetSid);
+      if (!target) {
+        if (typeof ack === "function") ack(undefined);
+        return;
+      }
+      const id = randomUUID();
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        if (typeof ack === "function") ack(undefined);
+      }, DEFAULT_ACTION_TIMEOUT_MS);
+      pending.set(id, {
+        sid: targetSid,
+        timer,
+        resolve: (v) => { if (typeof ack === "function") ack(v); },
+      });
+      target.emit("serve_call", { id, topic, payload });
+    });
+
+    socket.on("disconnect", () => cleanupSocket(socket));
+  });
+
+  return new Promise((resolve) => {
+    httpServer.once("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        log.warn(`Socket.IO bridge already running on :${port} — skipping`);
+        io.close();
+        httpServer.close();
+        resolve({ close: () => {} });
+      } else {
+        throw err;
+      }
+    });
+
+    httpServer.listen(port, host, () => {
+      log.step(`Socket.IO bridge listening on ws://127.0.0.1:${port}`);
+
+      const close = () => {
+        for (const p of pending.values()) {
+          clearTimeout(p.timer);
+          p.resolve(undefined);
+        }
+        pending.clear();
+        queryables.clear();
+        io.close();
+        httpServer.close();
+      };
+
+      resolve({ close });
+    });
+  });
+}
+
+// When executed directly (inside the bridge Docker container), start the server.
+if (process.argv[1] && process.argv[1] === fileURLToPath(import.meta.url)) {
+  const port = Number(process.env.PORT) || 10000;
+  startSocketBridge({ port });
+}

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":"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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"};

package/cli/src/type.mjs

@@ -0,0 +1,105 @@
+// muscat-pk type change — switch an existing plugin's backend type.
+//   python | cpp | ros2 (rclpy) | ros2-cpp (rclcpp).
+//   Adds the matching backend overlay; never deletes existing user code
+//   (e.g. ros2_ws/ or cpp/ are left in place when switching away).
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { findPluginRoot, log, prompt } from "./util.mjs";
+import {
+  TYPE_CHOICES,
+  applyTokens,
+  deriveNames,
+  overlayCpp,
+  overlayRos2,
+  runtimeForChoice,
+} from "./new.mjs";
+
+const TYPES = Object.keys(TYPE_CHOICES);
+
+function readManifest(root) {
+  const path = resolve(root, "manifest.json");
+  if (!existsSync(path)) throw new Error(`manifest.json not found in ${root}`);
+  return { path, json: JSON.parse(readFileSync(path, "utf8")) };
+}
+
+// Derive the current `--type`-style key from a manifest runtime block.
+function currentTypeKey(runtime) {
+  if (runtime?.type === "ros2") return runtime.rosClient === "rclcpp" ? "ros2-cpp" : "ros2";
+  return runtime?.type ?? "python";
+}
+
+export async function runType(args) {
+  // accept `type change`, `type`, `type --to ros2-cpp`
+  const sub = args[0];
+  const toFlagIdx = args.indexOf("--to");
+  let to = toFlagIdx >= 0 ? args[toFlagIdx + 1] : undefined;
+
+  const root = findPluginRoot();
+  const { path, json } = readManifest(root);
+  const current = currentTypeKey(json.runtime);
+
+  if (sub && sub !== "change") {
+    log.warn(`unknown subcommand '${sub}'. Usage: muscat-pk type change [--to python|cpp|ros2|ros2-cpp]`);
+  }
+
+  if (!to) {
+    console.log(`\n현재 타입: ${current}`);
+    console.log("변경할 타입을 선택하세요:");
+    console.log("  1) Python");
+    console.log("  2) C++");
+    console.log("  3) ROS2 (rclpy / Python)");
+    console.log("  4) ROS2 (rclcpp / C++)");
+    const choice = await prompt("\n선택 [1/2/3/4]: ", "");
+    to = { "1": "python", "2": "cpp", "3": "ros2", "4": "ros2-cpp" }[choice];
+  }
+
+  if (!TYPES.includes(to)) {
+    throw new Error(`invalid type. choose python | cpp | ros2 | ros2-cpp.`);
+  }
+  if (to === current) {
+    log.info(`already '${current}' — nothing to change.`);
+    return;
+  }
+
+  const runtimeChoice = TYPE_CHOICES[to];
+  const { slug, pluginName, pluginClass, pluginId } = deriveNames(root);
+
+  if (runtimeChoice.type === "ros2") {
+    if (existsSync(resolve(root, "ros2_ws"))) {
+      log.warn("ros2_ws/ already exists — keeping it, only flipping manifest type.");
+    } else {
+      log.step(`adding ros2_ws/ overlay (${runtimeChoice.rosClient})`);
+      await overlayRos2(root, slug, runtimeChoice.rosClient);
+      applyTokens(root, {
+        __PLUGIN_ID__: pluginId,
+        __PLUGIN_NAME__: pluginName,
+        __PLUGIN_SLUG__: slug,
+        __PLUGIN_CLASS__: pluginClass,
+        __RUNTIME_TYPE__: "ros2",
+      });
+    }
+  } else if (runtimeChoice.type === "cpp") {
+    if (existsSync(resolve(root, "cpp"))) {
+      log.warn("cpp/ already exists — keeping it, only flipping manifest type.");
+    } else {
+      log.step("adding cpp/ overlay");
+      await overlayCpp(root);
+      applyTokens(root, {
+        __PLUGIN_ID__: pluginId,
+        __PLUGIN_NAME__: pluginName,
+        __PLUGIN_SLUG__: slug,
+        __PLUGIN_CLASS__: pluginClass,
+        __RUNTIME_TYPE__: "cpp",
+      });
+    }
+  } else {
+    // → python. Leave any ros2_ws/ or cpp/ in place (never delete user code).
+    if (existsSync(resolve(root, "ros2_ws")) || existsSync(resolve(root, "cpp"))) {
+      log.warn("existing backend dir left in place (not deleted). Remove it manually if unused.");
+    }
+  }
+
+  json.runtime = runtimeForChoice(runtimeChoice, slug);
+  writeFileSync(path, JSON.stringify(json, null, 2) + "\n");
+  log.ok(`${basename(root)} type: ${current} → ${to}`);
+}

package/cli/src/uninstall.mjs

@@ -0,0 +1,98 @@
+// muscat-pk uninstall - remove the installed CLI, whether npm-global or S3 binary.
+import { execSync, spawn, spawnSync } from "node:child_process";
+import { existsSync, realpathSync, rmSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { KIT_PUBLISHED_NAME, kitRoot, log, parseArgs } from "./util.mjs";
+
+const isBinaryMode = typeof Bun !== "undefined";
+
+function isInside(child, parent) {
+  const rel = relative(parent, child);
+  return rel === "" || (!!rel && !rel.startsWith("..") && !rel.includes(":"));
+}
+
+function npmGlobalRoot() {
+  return execSync("npm root -g", { encoding: "utf8" }).trim();
+}
+
+function isNpmGlobalInstall() {
+  try {
+    return isInside(realpathSync(kitRoot), realpathSync(npmGlobalRoot()));
+  } catch {
+    return false;
+  }
+}
+
+function uninstallNpmGlobal() {
+  log.step(`npm uninstall -g ${KIT_PUBLISHED_NAME}`);
+  execSync(`npm uninstall -g ${KIT_PUBLISHED_NAME}`, { stdio: "inherit" });
+  log.ok("Global npm package removed.");
+}
+
+function uninstallBinary() {
+  const execPath = process.execPath;
+  log.step(`Removing binary: ${execPath}`);
+
+  if (process.platform === "win32") {
+    const ps = `Start-Sleep -Milliseconds 500; Remove-Item -Force '${execPath}'`;
+    spawn("powershell", ["-NoProfile", "-Command", ps], {
+      detached: true,
+      stdio: "ignore",
+    }).unref();
+    log.ok("Binary will be removed after this process exits.");
+    return;
+  }
+
+  try {
+    rmSync(execPath, { force: true });
+  } catch (err) {
+    if (err?.code !== "EACCES" && err?.code !== "EPERM") throw err;
+    log.info("  sudo is required...");
+    const result = spawnSync("sudo", ["rm", "-f", execPath], { stdio: "inherit" });
+    if (result.status !== 0) throw new Error(`sudo rm failed: ${execPath}`);
+  }
+
+  const parent = dirname(execPath);
+  for (const shim of ["muscat-pk.cmd", "muscat-pk.ps1"]) {
+    rmSync(join(parent, shim), { force: true });
+  }
+
+  log.ok("Binary removed.");
+}
+
+export async function runUninstall(args = []) {
+  const opts = parseArgs(args, { booleans: ["help"] });
+
+  if (opts.help) {
+    log.info(
+      [
+        "Usage: muscat-pk uninstall",
+        "",
+        "Removes the installed muscat-pk CLI.",
+        "  npm global install  -> npm uninstall -g @rainbow-robotics/muscat-plugin-kit",
+        "  S3 binary install   -> remove the muscat-pk executable",
+      ].join("\n"),
+    );
+    return;
+  }
+
+  if (isBinaryMode) {
+    uninstallBinary();
+    return;
+  }
+
+  if (isNpmGlobalInstall()) {
+    uninstallNpmGlobal();
+    return;
+  }
+
+  const localBin = process.argv[1] || "";
+  if (localBin.includes(`${join("node_modules", ".bin")}`) || existsSync(join(process.cwd(), "package.json"))) {
+    log.warn("This muscat-pk appears to be running from a project/local install.");
+    log.warn("Remove it from the project package manager instead, for example:");
+    log.warn(`  npm uninstall ${KIT_PUBLISHED_NAME}`);
+    return;
+  }
+
+  throw new Error("Could not determine install mode. Remove muscat-pk manually from your PATH.");
+}