@rainbow-robotics/muscat-plugin-kit 1.3.3 → 1.3.6-dev.0

package/cli/docker/Dockerfile.cpp

@@ -12,7 +12,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 
 # Rainbow Robotics C++ SDK for find_package(rb_sdk).
 # Override with MUSCAT_PK_RB_SDK_VERSION=<ver> (+ MUSCAT_PK_REBUILD_IMAGE=1).
-ARG RB_SDK_VERSION=0.1.3
+ARG RB_SDK_VERSION=0.1.6
 RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates curl \
     && install -d /etc/apt/keyrings \
     && curl -fsSL https://rainbowrobotics.github.io/rb-sdk/rb-sdk-apt-repo.gpg.key -o /etc/apt/keyrings/rb-sdk.asc \

package/cli/docker/Dockerfile.dev

@@ -11,7 +11,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 
 # Rainbow Robotics C++ SDK for find_package(rb_sdk).
 # Override with MUSCAT_PK_RB_SDK_VERSION=<ver> (+ MUSCAT_PK_REBUILD_IMAGE=1).
-ARG RB_SDK_VERSION=0.1.3
+ARG RB_SDK_VERSION=0.1.6
 RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates curl \
     && install -d /etc/apt/keyrings \
     && curl -fsSL https://rainbowrobotics.github.io/rb-sdk/rb-sdk-apt-repo.gpg.key -o /etc/apt/keyrings/rb-sdk.asc \

package/cli/src/build.mjs

@@ -74,6 +74,21 @@ function runViteBuild(pluginRoot, { mode = "production" } = {}) {
 // For ros2 plugins, compile the colcon workspace inside the Jazzy + Python 3.12 container.
 // rclpy: arch-agnostic (pure Python) → dist/ros2_ws/install/ (built once)
 // rclcpp: arch-specific C++ binaries → dist/ros2_ws/install-{arch}/ per arch
+// Cross-arch C++ builds run inside an emulated container. Docker Desktop ships the
+// emulation; native Linux needs binfmt/QEMU — check up front so the error says so.
+function assertCanBuildArch(arch, dockerPlatform) {
+  const info = spawnSync("docker", ["info", "--format", "{{.Architecture}}"], { encoding: "utf8" });
+  const host = { x86_64: "amd64", aarch64: "arm64", arm64: "arm64" }[(info.stdout || "").trim()] ?? "";
+  if (arch === host) return;
+  const r = spawnSync("docker", ["run", "--rm", "--platform", dockerPlatform, "ubuntu:24.04", "true"], { stdio: "ignore" });
+  if (r.status === 0) return;
+  throw new Error(
+    `can't build ${arch} on this ${host || "machine"}: Docker has no ${arch} emulation.\n` +
+    `  enable it once:  docker run --privileged --rm tonistiigi/binfmt --install ${arch}\n` +
+    `  or build only this machine's arch:  muscat-pk build --arch ${host || "<arch>"}`,
+  );
+}
+
 export async function exportRos2Build(root, archs = ["amd64", "arm64"]) {
   if (manifestRuntime(root) !== "ros2") return;
   const { assertDockerReady, ensureImage, colconBuild, ROS2_DEV_IMAGE, ARCH_DOCKER_PLATFORM } = await import("./ros2.mjs");
@@ -85,6 +100,7 @@ export async function exportRos2Build(root, archs = ["amd64", "arm64"]) {
     for (const arch of archs) {
       const dockerPlatform = ARCH_DOCKER_PLATFORM[arch];
       if (!dockerPlatform) throw new Error(`unknown arch '${arch}'`);
+      assertCanBuildArch(arch, dockerPlatform);
       await ensureImage(`${ROS2_DEV_IMAGE}-${arch}`, { platform: dockerPlatform });
       colconBuild(root, { symlink: false, arch });
       log.ok(`dist/ros2_ws/install-${arch}/ ready`);
@@ -111,6 +127,7 @@ export async function exportCppBuild(root, distDir, archs = ["amd64", "arm64"])
   for (const arch of archs) {
     const dockerPlatform = ARCH_DOCKER_PLATFORM[arch];
     if (!dockerPlatform) throw new Error(`unknown arch '${arch}'`);
+    assertCanBuildArch(arch, dockerPlatform);
     await ensureImage(`${CPP_DEV_IMAGE}-${arch}`, { platform: dockerPlatform });
     cmakeBuild(root, { buildType: "Release", arch });
     const built = resolve(root, `cpp/build-${arch}`, entry);

package/cli/src/devBack.mjs

@@ -8,11 +8,12 @@
 //   ros2   : Jazzy + Python 3.12 container, colcon build, run the node, restart
 //            on source changes (rclcpp rebuilds on change).
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync, watch } from "node:fs";
-import { resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, watch, writeFileSync } from "node:fs";
+import { isIP } from "node:net";
+import { dirname, resolve } from "node:path";
 import { ensureDocker, ensureIdeVenv, findPluginRoot, log, promptRobotConnection, realtimeFlags } from "./util.mjs";
 import { ensureRemoteZenohEnv, usesHostNetwork } from "./zenohDev.mjs";
-import { assertManifestPorts, assertManifestVariables, manifestRuntime, readManifest, validateManifest } from "./manifest.mjs";
+import { PLUGIN_ID_RE, assertManifestPorts, assertManifestVariables, manifestRuntime, readManifest, rosNamespace, validateManifest } from "./manifest.mjs";
 import {
   formatPortRanges,
   portEnvFlags,
@@ -69,6 +70,43 @@ function backendNetwork(portRanges) {
   };
 }
 
+// rb.rosPeers in dev: answer muscat/plugin/<id>/ros_peers/{get,set} on the gateway the way
+// Muscat (common) does on the robot — keep the list in .muscat-dev/ and restart the node
+// with ROS_STATIC_PEERS.
+const ROS_PEERS_FILE = ".muscat-dev/ros-peers.json";
+
+function readRosPeers(root) {
+  try {
+    return JSON.parse(readFileSync(resolve(root, ROS_PEERS_FILE), "utf8"));
+  } catch {
+    return [];
+  }
+}
+
+async function serveRosPeers(root, pluginId, restart) {
+  if (!pluginId) return;
+  const { RbWs } = await import("@rainbow-robotics/plugin-ui/ws");
+  const ws = await Promise.race([
+    RbWs.connect("http://127.0.0.1:10000", pluginId).catch(() => null),
+    new Promise((r) => setTimeout(() => r(null), 5000)),
+  ]);
+  if (!ws) return log.warn("rb.rosPeers unavailable in dev: plugin gateway not reachable on :10000");
+  const base = `/muscat/plugin/${pluginId}/ros_peers`;
+  await ws.serve(`${base}/get`, () => ({ peers: readRosPeers(root) }));
+  await ws.serve(`${base}/set`, (payload) => {
+    const peers = payload?.peers;
+    if (!Array.isArray(peers) || !peers.every((p) => typeof p === "string" && isIP(p))) {
+      return { ok: false, error: "peers must be a list of IP addresses" };
+    }
+    const file = resolve(root, ROS_PEERS_FILE);
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(peers) + "\n");
+    log.step(`ROS_STATIC_PEERS → ${peers.join(";") || "(none)"} — restarting node`);
+    restart();
+    return { ok: true, peers };
+  });
+}
+
 // Our own MediaMTX, only when `dev` found its ports free (a local Muscat brings its own).
 function startMediaServer(container) {
   if (process.env.MUSCAT_PK_MEDIA !== "1") return;
@@ -435,6 +473,8 @@ async function runRos2(root, portRanges) {
     // Same rationale as runPython(): no -t on docker exec below means
     // rclpy's Python process stdout is block-buffered, not line-buffered.
     "-e", "PYTHONUNBUFFERED=1",
+    // Same as the robot: ROS discovery stays on this host (allow a PC with ROS_STATIC_PEERS).
+    "-e", "ROS_AUTOMATIC_DISCOVERY_RANGE=LOCALHOST",
     ...net.env,
     ...(pluginId    ? ["-e", `RB_PLUGIN_ID=${pluginId}`]             : []),
     ...(robotIp     ? ["-e", `MUSCAT_ROBOT_HOST=${robotIp}`]         : []),
@@ -463,18 +503,24 @@ async function runRos2(root, portRanges) {
   let child = null;
   const startNode = () => {
     if (child) child.kill();
-    // Same command the robot runs: rclpy execs the console script, rclcpp uses `ros2 run`.
+    // killing the `docker exec` client doesn't stop the node inside the container
+    spawnSync("docker", ["exec", container, "pkill", "-f", `${pkg}_node|${manifest.runtime?.launch || pkg}`], { stdio: "ignore" });
+    const peers = readRosPeers(root);
+    // Same command the robot runs: rclpy execs the console script, rclcpp uses `ros2 run`;
+    // relative topics land under the plugin's namespace (rosNamespace).
     const launch = manifest.runtime?.launch || `${pkg}_node`;
-    const run = isRclcpp ? `ros2 run ${pkg} ${launch}` : `exec ${launch}`;
+    const nsArgs = PLUGIN_ID_RE.test(pluginId) ? ` --ros-args -r __ns:=${rosNamespace(pluginId)}` : "";
+    const run = (isRclcpp ? `ros2 run ${pkg} ${launch}` : `exec ${launch}`) + nsArgs;
     log.step(run);
     child = spawn(
       "docker",
-      ["exec", ...envFlags, container, "bash", "-lc",
+      ["exec", ...envFlags, ...(peers.length ? ["-e", `ROS_STATIC_PEERS=${peers.join(";")}`] : []), container, "bash", "-lc",
         `cd ros2_ws && source install/setup.bash && ${run}`],
       { cwd: root, stdio: "inherit" },
     );
   };
   startNode();
+  serveRosPeers(root, pluginId, startNode);
 
   // restart node on source change. rclpy reflects .py edits live (symlink-install);
   // rclcpp (C++) and package-metadata changes require a colcon rebuild.

package/cli/src/manifest.mjs

@@ -11,6 +11,15 @@ export const CONTRIBUTION_POINTS = [
   "program.panel",
 ];
 const ICON_SIZES = ["16", "48", "128"];
+// Reverse-domain id: "."-separated parts of lowercase letters/digits joined by single "-",
+// each part starting with a letter. Keeps the ROS namespace derived from it (rosNamespace)
+// valid and collision-free (no "_" in ids, so "." and "-" map to distinct characters).
+export const PLUGIN_ID_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*(\.[a-z][a-z0-9]*(-[a-z0-9]+)*)*$/;
+
+/** ROS namespace for a plugin id: "." → "/", "-" → "_" (com.example.my-plugin → /com/example/my_plugin). */
+export function rosNamespace(id) {
+  return "/" + id.replace(/\./g, "/").replace(/-/g, "_");
+}
 const RUNTIME_TYPES = ["none", "python", "cpp", "ros2"];
 const ROS_CLIENTS = ["rclpy", "rclcpp"];
 const I18N_LANGS = ["ko", "en", "ja", "zh", "vi", "th", "es"];
@@ -192,6 +201,8 @@ export function validateManifest(manifest) {
     if (typeof manifest[key] !== "string" || manifest[key].length === 0)
       errors.push(`"${key}" is required`);
   }
+  if (typeof manifest.id === "string" && manifest.id && !PLUGIN_ID_RE.test(manifest.id))
+    errors.push(`"id" must be "."-separated parts of lowercase letters/digits and single "-", each starting with a letter (e.g. com.example.my-plugin)`);
   if (typeof manifest.author !== "string" || manifest.author.length === 0)
     errors.push(`"author" is required`);
   if (typeof manifest.email !== "string" || manifest.email.length === 0)

package/cli/src/mcp.mjs

@@ -683,7 +683,8 @@ export async function runMcp() {
         "host), manifest.json (including the \"variables\" declaration for the pyfm variable picker — " +
         "names require the RBP_ prefix), program variables & executor state (ctx.get_variable/" +
         "set_variable/executor_state/check_stop), video streaming (MediaMTX: backend publishes RTSP to " +
-        "127.0.0.1:8554, UI plays WebRTC from :8889), contribution points, and backend runtimes " +
+        "127.0.0.1:8554, UI plays WebRTC from :8889), ROS 2 topics (plugin namespace, rb.rosPeers to allow " +
+        "an external PC), contribution points, and backend runtimes " +
         "(Python/C++/ROS2). Covers BOTH backends: the Python README (py/main.py, rainbow.rb_sdk) and the " +
         "C++ README (cpp/main.cpp or an rclcpp node: rb_plugin::RBPluginCall serve/subscribe/publish/" +
         "router(), rb_plugin::PluginProgramContext, RBManipulateSDK, CMake rb_sdk::rb_sdk). Pass lang " +

package/cli/src/new.mjs

@@ -106,6 +106,12 @@ export function applyTokens(dir, tokens) {
 }
 
 // Derive naming tokens from a plugin directory name.
+// One id part (see PLUGIN_ID_RE): lowercase, single "-", starts with a letter.
+function idPart(name) {
+  const part = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return /^[a-z]/.test(part) ? part : part ? `plugin-${part}` : "plugin";
+}
+
 export function deriveNames(target) {
   const base = basename(target);
   const slug = base.toLowerCase().replace(/[^a-z0-9]+/g, "_");
@@ -115,7 +121,7 @@ export function deriveNames(target) {
     slug,
     pluginName,
     pluginClass: pluginName.replace(/\s+/g, ""),
-    pluginId: `com.example.${base.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`,
+    pluginId: `com.example.${idPart(base)}`,
   };
 }