@rainbow-robotics/muscat-plugin-kit 0.1.2-dev.5 → 0.1.2-dev.51

package/cli/src/ros2.mjs

@@ -3,14 +3,10 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { hasBin, kitRoot, log } from "./util.mjs";
+import { hasBin, log, pruneMuskatImages, resolveDockerfile } from "./util.mjs";
 
 export const ROS2_DEV_IMAGE = "muscat-pk-ros2-dev";
 
-// Dockerfile lives inside the kit — plugin authors never see or edit it.
-// It has no COPY/ADD, so the build context is irrelevant (its own dir is used).
-const DOCKERFILE = resolve(kitRoot, "cli/docker/Dockerfile.dev");
-
 /** First package directory under ros2_ws/src (the colcon package name). */
 export function ros2PackageName(root) {
   const srcDir = resolve(root, "ros2_ws/src");
@@ -25,20 +21,25 @@ export function assertDockerReady() {
   if (!hasBin("docker")) {
     throw new Error("Docker not found. ROS2 needs Docker (Jazzy + Python 3.12 container).");
   }
-  if (!existsSync(DOCKERFILE)) {
-    throw new Error(`kit Dockerfile missing at ${DOCKERFILE} (reinstall muscat-plugin-kit).`);
-  }
 }
 
+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 function ensureImage(image = ROS2_DEV_IMAGE) {
-  log.step(`docker build -t ${image} (first run is slow, then cached)…`);
+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", "-t", image, "-f", DOCKERFILE, dirname(DOCKERFILE)],
+    ["build", ...platformFlags, "-t", image, "-f", dockerfile, dirname(dockerfile)],
     { stdio: "inherit" },
   );
   if (r.status !== 0) throw new Error("docker build failed.");
+  pruneMuskatImages();
 }
 
 /**
@@ -46,20 +47,44 @@ export function ensureImage(image = ROS2_DEV_IMAGE) {
  * (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).
  */
-export function colconBuild(root, { image = ROS2_DEV_IMAGE, symlink = false } = {}) {
+/**
+ * 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 = [
-    // --ignore-installed: don't try to uninstall debian-managed packages
-    // (e.g. psutil), which fails with "RECORD file not found".
     "pip install -r requirements.txt --break-system-packages --ignore-installed -q || true",
     "cd ros2_ws",
-    `colcon build ${flag}`.trim(),
+    // 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(" && ");
-  log.step(`colcon build${symlink ? " --symlink-install" : ""} (in container)…`);
+  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", "-v", `${root}:/plugin`, "-w", "/plugin", image, "bash", "-lc", script],
+    ["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.");
+  if (r.status !== 0) throw new Error(`colcon build failed${arch ? ` (${arch})` : ""}.`);
 }

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/socketBridge.mjs

@@ -0,0 +1,133 @@
+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);
+      log.step(`serve registered: ${data.topic}`);
+    });
+
+    socket.on("serve_unregister", (data = {}) => {
+      if (queryables.get(data.topic) === socket.id) queryables.delete(data.topic);
+      if (data.topic) log.step(`serve unregistered: ${data.topic}`);
+    });
+
+    socket.on("serve_reply", (data = {}) => {
+      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) {
+        log.warn(`action has no handler: ${topic}`);
+        if (typeof ack === "function") ack({ error: `No handler registered for ${topic}` });
+        return;
+      }
+      log.step(`action: ${topic}`);
+      const id = randomUUID();
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        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/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

@@ -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/.mcp.json":"ewogICJtY3BTZXJ2ZXJzIjogewogICAgIm11c2NhdCI6IHsKICAgICAgImNvbW1hbmQiOiAibXVzY2F0LXBrIiwKICAgICAgImFyZ3MiOiBbIm1jcCJdCiAgICB9CiAgfQp9Cg==","common/README.md":"# __PLUGIN_NAME__

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

## Quick start

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

---

## Project structure

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

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

---

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

### JavaScript dependencies

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

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

The scaffold keeps this split:

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

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

### Styles

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

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

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

#### Tailwind

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

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

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

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

```css
@layer theme, utilities;

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

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

#### SCSS, Sass, and Less

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

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

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

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

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

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

#### Emotion

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

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

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

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

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

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

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

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

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

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

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

### useRb() hook

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

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

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

### rb API

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

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


All methods support Generic Types:

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

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

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

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

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

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

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

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

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

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

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

### UI components

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

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

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

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

---

## Developing directly on the robot PC

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

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

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

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

---

## Backend runtimes

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

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

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

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

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

### Frontend-only (`none`)

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

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

### Python

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

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

plugin = RBPluginCall()


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


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


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


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


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


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

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

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

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

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

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

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


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

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

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

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

    # finish the step
    await ctx.done()


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

### C++

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

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

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

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

### ROS2 (rclpy)

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

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

sdk = RBManipulateSDK()


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

### ROS2 (rclcpp)

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

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

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

---

## manifest.json

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

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

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

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

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

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

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

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

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

**Backend types:**

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

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

**Contribution points:**

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

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

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

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

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

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

---

## Localized documentation

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

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

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

---

## Installing Python dependencies

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

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

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

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

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

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

---

## Switching backend type

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

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

---

## AI coding assistants (MCP)

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

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

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

### Register the server

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

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

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

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

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

---

## Shipping

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

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

ZIP layout:

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

---

## All commands

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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