@rainbow-robotics/muscat-plugin-kit 1.3.6-dev.6 → 1.3.6-dev.8

package/cli/README.md

@@ -60,10 +60,10 @@ and `50051` are reserved and must not be used by external plugins.
 | runtime | source | notes |
 |---|---|---|
 | `{ "type": "none" }` | — | UI-only plugin; no backend container |
-| `{ "type": "python", "entry": "main.py" }` | `py/` | Uses `rainbow.rb_sdk.RBPluginCall` for UI/backend messaging; `plugin.router` exposes external endpoints (`common/plugin/{id}/{path}`, needs sdk ≥ 0.0.9.dev5 on the robot; the dev bridge only registers routes — external calls need a running `common`) |
-| `{ "type": "cpp", "entry": "<executable name>" }` | `cpp/` | Built with CMake in Docker against the C++ SDK (apt `rainbow-rb-sdk-dev`, `find_package(rb_sdk)`, dynamic link) |
+| `{ "type": "python", "entry": "main.py" }` | `py/` | Uses `rainbow.rb_sdk.RBPluginCall` for UI/backend messaging |
+| `{ "type": "cpp", "entry": "<executable name>" }` | `cpp/` | Built with CMake in Docker; current template is a run skeleton |
 | `{ "type": "ros2", "rosClient": "rclpy", ... }` | `ros2_ws/` | ROS2 Python node; may use Python SDK alongside ROS2 APIs |
-| `{ "type": "ros2", "rosClient": "rclcpp", ... }` | `ros2_ws/` | ROS2 C++ node built with colcon/CMake, links the C++ SDK like `cpp` |
+| `{ "type": "ros2", "rosClient": "rclcpp", ... }` | `ros2_ws/` | ROS2 C++ node built with colcon/CMake |
 
 All non-`none` runtimes run in Docker during `muscat-pk dev:back`, `muscat-pk
 dev`, and build/export flows so development matches the robot environment.
@@ -257,11 +257,6 @@ would break `dev` offline. Pre-seed an air-gapped machine with
 `docker save … | gzip` + `docker load`, or force a rebuild with
 `MUSCAT_PK_REBUILD_IMAGE=1`.
 
-The C++ images (`Dockerfile.cpp`, `Dockerfile.dev`) install `rainbow-rb-sdk-dev`
-from `https://rainbowrobotics.github.io/rb-sdk` (suite `dev`), pinned by the
-`RB_SDK_VERSION` build arg. Set `MUSCAT_PK_RB_SDK_VERSION=<version>` (with
-`MUSCAT_PK_REBUILD_IMAGE=1`) to match a robot running a different SDK version.
-
 On Linux the dev containers run as the invoking user (`--user`), so build output
 under `dist/` and `cpp/build-*` is not left root-owned.
 

package/cli/bin/muscat-pk.mjs

@@ -35,11 +35,6 @@ function readVersion(binPath) {
 
 const isBinaryMode = typeof Bun !== "undefined";
 
-// 바이너리에는 package.json 이 없다 — 컴파일 시 임베드한 버전을 쓴다.
-if (isBinaryMode && !process.env.MUSCAT_PK_VERSION) {
-  process.env.MUSCAT_PK_VERSION = (await import("../src/templates-embedded.mjs")).KIT_VERSION;
-}
-
 (function delegateToLocalInstall() {
   try {
     const localBin = resolveLocalCliBin();

package/cli/bundle-templates.mjs

@@ -2,7 +2,7 @@
 // Pre-build step: serialise cli/templates/** into cli/src/templates-embedded.mjs
 // so that `bun build --compile` can embed them without needing the filesystem.
 import { readdirSync, readFileSync, writeFileSync, statSync } from "node:fs";
-import { resolve } from "node:path";
+import { resolve, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const root = resolve(fileURLToPath(import.meta.url), "..");
@@ -19,15 +19,10 @@ function walk(baseDir, prefix) {
 }
 walk(resolve(root, "templates") + "/", "");
 walk(resolve(root, "docker") + "/", "docker/");
-// Dockerfile.bridge 의 COPY 대상
-files["src/socketBridge.mjs"] = readFileSync(resolve(root, "src/socketBridge.mjs"), "base64");
-
-const { version } = JSON.parse(readFileSync(resolve(root, "../package.json"), "utf8"));
 
 writeFileSync(out,
   `// AUTO-GENERATED by cli/bundle-templates.mjs — do not edit.\n` +
   `// ponytail: generated at publish time; not tracked in git.\n` +
-  `export const KIT_VERSION = ${JSON.stringify(version)};\n` +
   `export const TEMPLATES = ${JSON.stringify(files)};\n`
 );
 console.log(`bundled ${Object.keys(files).length} template files → src/templates-embedded.mjs`);

package/cli/docker/Dockerfile.cpp

@@ -10,34 +10,12 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
       cmake \
     && rm -rf /var/lib/apt/lists/*
 
-# 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.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 \
-    && printf 'deb [signed-by=/etc/apt/keyrings/rb-sdk.asc] https://rainbowrobotics.github.io/rb-sdk %s main\n' stable dev > /etc/apt/sources.list.d/rb-sdk.list \
-    && apt-get update && apt-get install -y --no-install-recommends "rainbow-rb-sdk-dev=${RB_SDK_VERSION}" \
-    && rm -rf /var/lib/apt/lists/*
-
-# MediaMTX — same version/ports as the Muscat runtime (rby2 scripts/backend/runtime/mediamtx.yml),
-# plus webrtcAdditionalHosts so a browser on the dev host reaches the WebRTC media port.
-ARG MEDIAMTX_VERSION=1.12.3
-RUN set -eux; \
-    apt-get update; apt-get install -y --no-install-recommends ca-certificates curl; rm -rf /var/lib/apt/lists/*; \
-    case "$(uname -m)" in x86_64) a=amd64 ;; aarch64|arm64) a=arm64 ;; *) exit 1 ;; esac; \
-    curl -fsSL "https://github.com/bluenviron/mediamtx/releases/download/v${MEDIAMTX_VERSION}/mediamtx_v${MEDIAMTX_VERSION}_linux_${a}.tar.gz" \
-      | tar -xz -C /usr/local/bin mediamtx; \
-    mkdir -p /etc/mediamtx; \
-    printf '%s\n' \
-      'logLevel: warn' \
-      'rtsp: yes' 'rtspAddress: :8554' \
-      'webrtc: yes' 'webrtcAddress: :8889' \
-      'webrtcLocalUDPAddress: :8189' 'webrtcLocalTCPAddress: :8189' \
-      'webrtcAdditionalHosts: [127.0.0.1]' 'webrtcAllowOrigin: "*"' \
-      'hls: no' 'rtmp: no' 'srt: no' 'api: no' \
-      'paths:' '  all_others:' '    source: publisher' \
-      > /etc/mediamtx/mediamtx.yml
+# TODO(cpp-sdk): install the rainbow cpp SDK (dev package) here, pinned to the
+# robot's version, so plugins build/link against the same SDK as production.
+# Plan: apt package + dynamic link (the robot provides the .so at runtime;
+# we do NOT bundle it into the plugin binary). e.g.:
+#   RUN apt-get update && apt-get install -y rainbow-cpp-sdk-dev=<robot-version> \
+#       && rm -rf /var/lib/apt/lists/*
 
 WORKDIR /plugin
 

package/cli/docker/Dockerfile.dev

@@ -9,38 +9,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
       python3-colcon-common-extensions \
     && rm -rf /var/lib/apt/lists/*
 
-# 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.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 \
-    && printf 'deb [signed-by=/etc/apt/keyrings/rb-sdk.asc] https://rainbowrobotics.github.io/rb-sdk %s main\n' stable dev > /etc/apt/sources.list.d/rb-sdk.list \
-    && apt-get update && apt-get install -y --no-install-recommends "rainbow-rb-sdk-dev=${RB_SDK_VERSION}" \
-    && rm -rf /var/lib/apt/lists/*
-
-# MediaMTX — same version/ports as the Muscat runtime (rby2 scripts/backend/runtime/mediamtx.yml),
-# plus webrtcAdditionalHosts so a browser on the dev host reaches the WebRTC media port.
-ARG MEDIAMTX_VERSION=1.12.3
-RUN set -eux; \
-    apt-get update; apt-get install -y --no-install-recommends ca-certificates curl; rm -rf /var/lib/apt/lists/*; \
-    case "$(uname -m)" in x86_64) a=amd64 ;; aarch64|arm64) a=arm64 ;; *) exit 1 ;; esac; \
-    curl -fsSL "https://github.com/bluenviron/mediamtx/releases/download/v${MEDIAMTX_VERSION}/mediamtx_v${MEDIAMTX_VERSION}_linux_${a}.tar.gz" \
-      | tar -xz -C /usr/local/bin mediamtx; \
-    mkdir -p /etc/mediamtx; \
-    printf '%s\n' \
-      'logLevel: warn' \
-      'rtsp: yes' 'rtspAddress: :8554' \
-      'webrtc: yes' 'webrtcAddress: :8889' \
-      'webrtcLocalUDPAddress: :8189' 'webrtcLocalTCPAddress: :8189' \
-      'webrtcAdditionalHosts: [127.0.0.1]' 'webrtcAllowOrigin: "*"' \
-      'hls: no' 'rtmp: no' 'srt: no' 'api: no' \
-      'paths:' '  all_others:' '    source: publisher' \
-      > /etc/mediamtx/mediamtx.yml
-
-# `docker exec` skips /ros_entrypoint.sh — source ROS for the login shells dev:back runs.
-RUN echo ". /opt/ros/${ROS_DISTRO}/setup.sh" > /etc/profile.d/ros.sh
-
 WORKDIR /plugin
 
 CMD ["bash"]

package/cli/docker/Dockerfile.python

@@ -15,25 +15,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 # cpp SDK shared lib must be present for the python module to load. Install the
 # rainbow cpp SDK (apt, pinned to the robot's version) here once it exists.
 
-# MediaMTX — same version/ports as the Muscat runtime (rby2 scripts/backend/runtime/mediamtx.yml),
-# plus webrtcAdditionalHosts so a browser on the dev host reaches the WebRTC media port.
-ARG MEDIAMTX_VERSION=1.12.3
-RUN set -eux; \
-    apt-get update; apt-get install -y --no-install-recommends ca-certificates curl; rm -rf /var/lib/apt/lists/*; \
-    case "$(uname -m)" in x86_64) a=amd64 ;; aarch64|arm64) a=arm64 ;; *) exit 1 ;; esac; \
-    curl -fsSL "https://github.com/bluenviron/mediamtx/releases/download/v${MEDIAMTX_VERSION}/mediamtx_v${MEDIAMTX_VERSION}_linux_${a}.tar.gz" \
-      | tar -xz -C /usr/local/bin mediamtx; \
-    mkdir -p /etc/mediamtx; \
-    printf '%s\n' \
-      'logLevel: warn' \
-      'rtsp: yes' 'rtspAddress: :8554' \
-      'webrtc: yes' 'webrtcAddress: :8889' \
-      'webrtcLocalUDPAddress: :8189' 'webrtcLocalTCPAddress: :8189' \
-      'webrtcAdditionalHosts: [127.0.0.1]' 'webrtcAllowOrigin: "*"' \
-      'hls: no' 'rtmp: no' 'srt: no' 'api: no' \
-      'paths:' '  all_others:' '    source: publisher' \
-      > /etc/mediamtx/mediamtx.yml
-
 WORKDIR /plugin
 
 CMD ["bash"]

package/cli/src/bridge.mjs

@@ -5,41 +5,24 @@
 //     it at localhost:10000 too — no host.docker.internal needed (robust cross-OS).
 import { spawnSync } from "node:child_process";
 import { createServer, connect } from "node:net";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
 import { canSkipImageBuild, hasBin, kitRoot, log, pruneMuskatImages } from "./util.mjs";
-import { MEDIA_PORTS, mediaPortFlags } from "./ports.mjs";
-import { usesHostNetwork } from "./zenohDev.mjs";
 
 export const BRIDGE_IMAGE = "muscat-pk-bridge";
 export const BRIDGE_CONTAINER = "muscat-pk-bridge-run";
 export const BRIDGE_PORT = 10000;
 
-// 컴파일된 바이너리에는 cli/ 트리가 없어 임베드 스냅샷에서 build context 를 tmp 에 복원한다.
-const BRIDGE_CONTEXT_FILES = ["docker/Dockerfile.bridge", "docker/bridge-package.json", "src/socketBridge.mjs"];
-
-async function resolveBridgeContext() {
-  const context = resolve(kitRoot, "cli");
-  const dockerfile = resolve(context, "docker/Dockerfile.bridge");
-  if (existsSync(dockerfile)) return { dockerfile, context };
-
-  const { TEMPLATES } = await import("./templates-embedded.mjs");
-  const dir = resolve(tmpdir(), "muscat-pk-bridge-context");
-  for (const key of BRIDGE_CONTEXT_FILES) {
-    const b64 = TEMPLATES[key];
-    if (!b64) throw new Error(`Embedded file missing: ${key}. Reinstall muscat-plugin-kit.`);
-    const file = resolve(dir, key);
-    mkdirSync(dirname(file), { recursive: true });
-    writeFileSync(file, Buffer.from(b64, "base64"));
-  }
-  return { dockerfile: resolve(dir, "docker/Dockerfile.bridge"), context: dir };
-}
+const DOCKERFILE = resolve(kitRoot, "cli/docker/Dockerfile.bridge");
+const BUILD_CONTEXT = resolve(kitRoot, "cli");
 
 function assertDockerReady() {
   if (!hasBin("docker")) {
     throw new Error("Docker not found. `muscat-pk dev` runs the Socket.IO bridge in a container.");
   }
+  if (!existsSync(DOCKERFILE)) {
+    throw new Error(`kit Dockerfile missing at ${DOCKERFILE} (reinstall muscat-plugin-kit).`);
+  }
 }
 
 // Is a host TCP port already bound? (Catches another bridge or a stray process.)
@@ -69,28 +52,20 @@ function waitForPort(port, timeoutMs = 15_000) {
   });
 }
 
-async function ensureImage() {
+function ensureImage() {
   if (canSkipImageBuild(BRIDGE_IMAGE)) {
     log.step(`${BRIDGE_IMAGE} already built — skipping docker build`);
     return;
   }
-  const { dockerfile, context } = await resolveBridgeContext();
   log.step(`docker build -t ${BRIDGE_IMAGE} (first run is slow, then cached)…`);
-  const r = spawnSync("docker", ["build", "-t", BRIDGE_IMAGE, "-f", dockerfile, context], { stdio: "inherit" });
+  const r = spawnSync("docker", ["build", "-t", BRIDGE_IMAGE, "-f", DOCKERFILE, BUILD_CONTEXT], { stdio: "inherit" });
   if (r.status !== 0) throw new Error("docker build failed (bridge image).");
   pruneMuskatImages();
 }
 
-/** A running Muscat container (e.g. muscat-dev) that owns host port 10000, or null. */
-export function localMuscatContainer() {
-  const r = spawnSync("docker", ["ps", "--filter", `publish=${BRIDGE_PORT}`, "--format", "{{.Names}}"], { encoding: "utf8" });
-  return (r.stdout || "").split("\n").map((n) => n.trim()).find((n) => n && n !== BRIDGE_CONTAINER) ?? null;
-}
-
 /**
  * Build the image, preflight the port, and start the bridge container.
- * Returns false if port 10000 was already in use (caller decides), else { media }:
- * whether the MediaMTX ports are free for the backend's own MediaMTX.
+ * Returns true if bridge started, false if port was already in use (caller decides).
  */
 export async function startBridge({ zenohPort = null, pluginPorts = [] } = {}) {
   assertDockerReady();
@@ -113,14 +88,7 @@ export async function startBridge({ zenohPort = null, pluginPorts = [] } = {}) {
   }
   const publishable = pluginPorts.filter((port) => !busy.includes(port));
 
-  const mediaBusy = [];
-  for (const port of MEDIA_PORTS) {
-    if (await isPortInUse(port)) mediaBusy.push(port);
-  }
-  const media = mediaBusy.length === 0;
-  if (!media) log.warn(`MediaMTX port(s) already in use: ${mediaBusy.join(", ")} — video streaming disabled in dev.`);
-
-  await ensureImage();
+  ensureImage();
 
   log.step("starting Socket.IO bridge container…");
   // The backend joins THIS container's netns (--network container:), and a
@@ -130,7 +98,6 @@ export async function startBridge({ zenohPort = null, pluginPorts = [] } = {}) {
     "-p", `127.0.0.1:${BRIDGE_PORT}:${BRIDGE_PORT}`,
     ...(zenohPort ? ["-p", `${zenohPort}:${zenohPort}`] : []),
     ...publishable.flatMap((port) => ["-p", `127.0.0.1:${port}:${port}`]),
-    ...(media && !usesHostNetwork() ? mediaPortFlags() : []),
   ];
   const up = spawnSync(
     "docker",
@@ -144,7 +111,7 @@ export async function startBridge({ zenohPort = null, pluginPorts = [] } = {}) {
   if (zenohPort) log.step(`Zenoh dev peer port published on :${zenohPort}`);
   if (publishable.length > 0)
     log.step(`plugin backend ports published on 127.0.0.1: ${publishable.join(", ")}`);
-  return { media };
+  return true;
 }
 
 export function stopBridge() {

package/cli/src/build.mjs

@@ -74,36 +74,34 @@ 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;
+  if (manifestRuntime(root) !== "ros2") return [];
   const { assertDockerReady, ensureImage, colconBuild, ROS2_DEV_IMAGE, ARCH_DOCKER_PLATFORM } = await import("./ros2.mjs");
-  assertDockerReady();
+  try {
+    assertDockerReady();
+  } catch (e) {
+    log.warn(`ros2 build skipped: ${e.message}`);
+    return [];
+  }
 
   const manifest = JSON.parse(readFileSync(resolve(root, "manifest.json"), "utf8"));
-  if (manifest.runtime?.rosClient === "rclcpp") {
+  const rosClient = manifest.runtime?.rosClient;
+
+  const skipped = [];
+  if (rosClient === "rclcpp") {
     // C++ ROS2: compile per arch so each robot picks the right install-{arch}/
     for (const arch of archs) {
       const dockerPlatform = ARCH_DOCKER_PLATFORM[arch];
-      if (!dockerPlatform) 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`);
+      if (!dockerPlatform) { log.warn(`unknown arch '${arch}' — skipped`); skipped.push(arch); continue; }
+      const archImage = `${ROS2_DEV_IMAGE}-${arch}`;
+      try {
+        await ensureImage(archImage, { platform: dockerPlatform });
+        colconBuild(root, { symlink: false, arch });
+        log.ok(`dist/ros2_ws/install-${arch}/ ready`);
+      } catch {
+        log.warn(`${arch} ros2 build skipped — QEMU not available`);
+        skipped.push(arch);
+      }
     }
   } else {
     // rclpy / pure Python: arch-agnostic, build once
@@ -111,38 +109,54 @@ export async function exportRos2Build(root, archs = ["amd64", "arm64"]) {
     colconBuild(root, { symlink: false });
     log.ok("dist/ros2_ws/install/ ready");
   }
+  return skipped;
 }
 
 // For cpp plugins, compile cpp/ inside the Ubuntu container (Release) per arch
 // and copy each binary into dist/{arch}/{entry} so the ZIP carries relocatable
-// robot-compatible executables.
+// robot-compatible executables. rb-runtime prefers dist/{arch}/ and falls back
+// to dist/{entry} (legacy). Skipped (with a warning) if Docker is unavailable.
 export async function exportCppBuild(root, distDir, archs = ["amd64", "arm64"]) {
-  if (manifestRuntime(root) !== "cpp") return;
+  if (manifestRuntime(root) !== "cpp") return [];
   const { assertDockerReady, ensureImage, cmakeBuild, CPP_DEV_IMAGE, ARCH_DOCKER_PLATFORM } = await import("./cpp.mjs");
-  assertDockerReady();
+  try {
+    assertDockerReady();
+  } catch (e) {
+    log.warn(`cpp build skipped: ${e.message}`);
+    return [];
+  }
 
   const entry = JSON.parse(readFileSync(resolve(root, "manifest.json"), "utf8")).runtime?.entry;
-  if (!entry) throw new Error("manifest.json runtime.entry is required for cpp (the built executable name)");
+  if (!entry) {
+    log.warn("manifest.json runtime.entry not set — cpp build skipped");
+    return;
+  }
 
+  const skipped = [];
   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);
-    if (!existsSync(built)) {
-      throw new Error(`cpp/build-${arch}/${entry} not found — the CMake target name must equal runtime.entry`);
+    if (!dockerPlatform) { log.warn(`unknown arch '${arch}' — skipped`); skipped.push(arch); continue; }
+    const archImage = `${CPP_DEV_IMAGE}-${arch}`;
+    try {
+      await ensureImage(archImage, { platform: dockerPlatform });
+      cmakeBuild(root, { buildType: "Release", arch });
+      const built = resolve(root, `cpp/build-${arch}`, entry);
+      if (existsSync(built)) {
+        const archDir = resolve(distDir, arch);
+        mkdirSync(archDir, { recursive: true });
+        const dest = resolve(archDir, entry);
+        copyFileSync(built, dest);
+        chmodSync(dest, 0o755);
+        log.ok(`cpp binary → dist/${arch}/${entry}`);
+      } else {
+        log.warn(`cpp binary not found at cpp/build-${arch}/${entry}`);
+      }
+    } catch {
+      log.warn(`${arch} cpp build skipped — QEMU not available`);
+      skipped.push(arch);
     }
-    const archDir = resolve(distDir, arch);
-    mkdirSync(archDir, { recursive: true });
-    const dest = resolve(archDir, entry);
-    copyFileSync(built, dest);
-    chmodSync(dest, 0o755);
-    const libDir = resolve(root, `cpp/build-${arch}`, "lib");
-    if (existsSync(libDir)) cpSync(libDir, resolve(archDir, "lib"), { recursive: true, verbatimSymlinks: true });
-    log.ok(`cpp binary → dist/${arch}/${entry}${existsSync(libDir) ? " (+ lib/)" : ""}`);
   }
+  return skipped;
 }
 
 const PRERELEASE_RE = /\.(dev|a|b|rc|alpha|beta)\d*/i;
@@ -412,12 +426,11 @@ export async function runBuild(args) {
 
   await promptVersion(root);
   const archs = await promptArch(args);
-  // Drop a previous ZIP of this version so a failed build can't leave a stale one to upload.
-  const version = JSON.parse(readFileSync(resolve(root, "manifest.json"), "utf8")).version || "0.0.0";
-  rmSync(resolve(root, `${basename(root)}-${version}.zip`), { force: true });
 
   const { pluginRoot, distDir } = await buildPlugin({ root, minify: true });
 
+  const skippedArches = { wheels: [], ros2: [], cpp: [] };
+
   // python / rclpy: lock + wheel vendor in Ubuntu 24.04 container
   if (!noLock) {
     const manifest = JSON.parse(readFileSync(resolve(root, "manifest.json"), "utf8")).runtime ?? {};
@@ -426,12 +439,30 @@ export async function runBuild(args) {
       (manifest.type === "ros2" && manifest.rosClient === "rclpy");
     if (needsLock) {
       const { lockAndVendor } = await import("./python.mjs");
-      await lockAndVendor(pluginRoot, archs);
+      try {
+        skippedArches.wheels = await lockAndVendor(pluginRoot, archs);
+      } catch (e) {
+        log.warn(`python lock/vendor skipped: ${e.message}`);
+        skippedArches.wheels = archs;
+      }
     }
   }
 
-  await exportRos2Build(root, archs);
-  await exportCppBuild(root, distDir, archs);
+  skippedArches.ros2 = await exportRos2Build(root, archs) ?? [];
+  skippedArches.cpp  = await exportCppBuild(root, distDir, archs) ?? [];
   calcInstalledSize(pluginRoot);
   if (!noZip) packZip(pluginRoot);
+
+  // Build summary
+  const allSkipped = [...new Set([...skippedArches.wheels, ...skippedArches.ros2, ...skippedArches.cpp])];
+  if (allSkipped.length > 0) {
+    const line = "─".repeat(58);
+    console.log(`\n${line}`);
+    log.warn(`Cross-arch builds skipped (QEMU not available): ${allSkipped.join(", ")}`);
+    if (skippedArches.wheels.length) log.warn(`  wheels:  ${skippedArches.wheels.join(", ")}`);
+    if (skippedArches.ros2.length)   log.warn(`  ros2:    ${skippedArches.ros2.join(", ")}`);
+    if (skippedArches.cpp.length)    log.warn(`  cpp:     ${skippedArches.cpp.join(", ")}`);
+    log.warn(`  Enable: docker run --privileged --rm tonistiigi/binfmt --install all`);
+    console.log(line);
+  }
 }

package/cli/src/cpp.mjs

@@ -3,7 +3,7 @@
 // Used by dev:back (interactive dev loop) and build (export the binary into the ZIP).
 import { spawnSync } from "node:child_process";
 import { dirname } from "node:path";
-import { canSkipImageBuild, imageKey, imageKeyLabel, dockerUserFlags, hasBin, log, pruneMuskatImages, resolveDockerfile } from "./util.mjs";
+import { canSkipImageBuild, dockerUserFlags, hasBin, log, pruneMuskatImages, resolveDockerfile } from "./util.mjs";
 
 export const CPP_DEV_IMAGE = "muscat-pk-cpp-dev";
 
@@ -15,19 +15,16 @@ export function assertDockerReady() {
 
 /** Build the dev image from the kit's bundled Dockerfile (Docker layer-caches). */
 export async function ensureImage(image = CPP_DEV_IMAGE, { platform = null } = {}) {
-  const dockerfile = await resolveDockerfile("Dockerfile.cpp");
-  const sdkVer = process.env.MUSCAT_PK_RB_SDK_VERSION;
-  const key = imageKey(dockerfile, sdkVer ?? "");
-  if (canSkipImageBuild(image, key)) {
+  if (canSkipImageBuild(image)) {
     log.step(`${image} already built — skipping docker build`);
     return;
   }
+  const dockerfile = await resolveDockerfile("Dockerfile.cpp");
   log.step(`docker build -t ${image}${platform ? ` (${platform})` : ""} (first run is slow, then cached)…`);
   const platformFlags = platform ? ["--platform", platform] : [];
-  const buildArgs = [...(sdkVer ? ["--build-arg", `RB_SDK_VERSION=${sdkVer}`] : []), ...imageKeyLabel(key)];
   const r = spawnSync(
     "docker",
-    ["build", ...platformFlags, ...buildArgs, "-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.");
@@ -53,12 +50,9 @@ export function cmakeBuild(root, { image = CPP_DEV_IMAGE, buildType = "Debug", a
   const platformFlags = dockerPlatform ? ["--platform", dockerPlatform] : [];
   // arch 빌드 시 arch별 이미지 사용 (로컬 이미지와 platform 불일치 방지)
   const actualImage = arch ? `${CPP_DEV_IMAGE}-${arch}` : image;
-  // Export builds ship lib/ next to the binary: librb_sdk.so (robot has no SDK) + any .so the
-  // plugin copied there itself. Found via RPATH $ORIGIN/lib.
   const script = [
-    `cmake -S cpp -B ${buildDir} -DCMAKE_BUILD_TYPE=${buildType}` + (arch ? ` -DCMAKE_BUILD_RPATH='$ORIGIN/lib'` : ""),
+    `cmake -S cpp -B ${buildDir} -DCMAKE_BUILD_TYPE=${buildType}`,
     `cmake --build ${buildDir} -j`,
-    ...(arch ? [`rm -f ${buildDir}/lib/librb_sdk.so.* && if readelf -d $(find ${buildDir} -maxdepth 1 -type f -executable) 2>/dev/null | grep -q librb_sdk; then mkdir -p ${buildDir}/lib && cp -a $(dpkg -L rainbow-rb-sdk | grep -E '/librb_sdk[.]so[.][0-9]') ${buildDir}/lib/; fi`] : []),
   ].join(" && ");
   const label = arch ? `cmake build (${buildType}, ${arch}, in container)…` : `cmake build (${buildType}, in container)…`;
   log.step(label);

package/cli/src/dev.mjs

@@ -6,7 +6,7 @@ import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { runDevUi } from "./devUi.mjs";
 import { runDevBack, stopDevBackContainers } from "./devBack.mjs";
-import { localMuscatContainer, startBridge, stopBridge, BRIDGE_CONTAINER, BRIDGE_PORT } from "./bridge.mjs";
+import { startBridge, stopBridge, BRIDGE_CONTAINER, BRIDGE_PORT } from "./bridge.mjs";
 import { assertManifestPorts, assertManifestVariables } from "./manifest.mjs";
 import { formatPortRanges } from "./ports.mjs";
 import {
@@ -138,11 +138,7 @@ export async function runDev(args = []) {
     pluginPorts: usesHostNetwork() ? [] : portRanges,
   });
 
-  const muscat = bridgeStarted ? null : localMuscatContainer();
-  if (muscat) {
-    log.step(`local Muscat container '${muscat}' owns :${BRIDGE_PORT} — backend joins its network (gateway, MediaMTX)`);
-    process.env.MUSCAT_PK_MUSCAT_CONTAINER = muscat;
-  } else if (!bridgeStarted) {
+  if (!bridgeStarted) {
     log.warn(`port ${BRIDGE_PORT} is already in use — can't start Socket.IO bridge.`);
     const answer = await prompt("  Proceed without Socket.IO bridge? [y/N]: ");
     if (answer.toLowerCase() !== "y") return;
@@ -151,7 +147,6 @@ export async function runDev(args = []) {
     // Tell dev:back which bridge container to share a netns with, so the backend
     // reaches the bridge at localhost:10000 (no host.docker.internal).
     process.env.MUSCAT_PK_BRIDGE_CONTAINER = BRIDGE_CONTAINER;
-    if (bridgeStarted.media) process.env.MUSCAT_PK_MEDIA = "1";
   }
 
   process.env.MUSCAT_PK_MANAGED_DEV = "1";