@rainbow-robotics/muscat-plugin-kit 0.1.2-dev.34 → 0.1.2-dev.36

package/cli/bin/muscat-pk.mjs

@@ -21,7 +21,7 @@ Usage: muscat-pk <command> [options]
 Commands:
   new [dir]        Scaffold a new plugin project (prompts: author, email, description, type, front-package-manager)
   type change      Switch backend type (python | cpp | ros2-python | ros2-cpp)
-  build            Build + lock deps + vendor wheels + zip (--no-zip: skip zip, --no-lock: skip python lock/vendor)
+  build            Build + lock deps + vendor wheels + zip (--no-zip: skip zip, --no-lock: skip python lock/vendor, --arch x86_64|aarch64|both)
   dev              Run Socket.IO bridge, dev:ui, and dev:back together
   dev:ui           Preview the plugin in a mini-Muscat (preview-host)
   dev:back         Run the plugin back end (python: watchfiles reload / ros2: Docker)

package/cli/src/build.mjs

@@ -14,8 +14,8 @@ import { createRequire } from "node:module";
 import { basename, dirname, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { execSync, spawnSync } from "node:child_process";
-import { ensureDocker, findPluginRoot, hasBin, humanSize, log } from "./util.mjs";
-import { assertManifest } from "./manifest.mjs";
+import { ensureDocker, findPluginRoot, hasBin, humanSize, log, parseArgs } from "./util.mjs";
+import { assertManifest, manifestRuntime } from "./manifest.mjs";
 
 // Find a usable node binary (for running vite as subprocess).
 function findNodeBin() {
@@ -60,45 +60,53 @@ function isMainBranch() {
   return branch === "main" || branch === "master";
 }
 
-function manifestRuntime(root) {
-  try {
-    return JSON.parse(readFileSync(resolve(root, "manifest.json"), "utf8")).runtime?.type ?? "python";
-  } catch {
-    return "python";
-  }
-}
-
-// For ros2 plugins, compile the colcon workspace inside the Jazzy + Python 3.12
-// container so the shipped ZIP carries ros2_ws/install. Real (non-symlink) build
-// → relocatable on the robot. Skipped (with a warning) if Docker is unavailable.
-export async function exportRos2Build(root) {
+// 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
+export async function exportRos2Build(root, archs = ["amd64", "arm64"]) {
   if (manifestRuntime(root) !== "ros2") return;
-  const { assertDockerReady, ensureImage, colconBuild } = await import("./ros2.mjs");
+  const { assertDockerReady, ensureImage, colconBuild, ROS2_DEV_IMAGE, ARCH_DOCKER_PLATFORM } = await import("./ros2.mjs");
   try {
     assertDockerReady();
   } catch (e) {
     log.warn(`ros2 build skipped: ${e.message}`);
     return;
   }
-  ensureImage();
-  colconBuild(root, { symlink: false });
-  log.ok("ros2_ws/install ready (will be included in the ZIP)");
+
+  const manifest = JSON.parse(readFileSync(resolve(root, "manifest.json"), "utf8"));
+  const rosClient = manifest.runtime?.rosClient;
+
+  if (rosClient === "rclcpp") {
+    // C++ ROS2: compile per arch so each robot picks the right install-{arch}/
+    for (const arch of archs) {
+      const dockerPlatform = ARCH_DOCKER_PLATFORM[arch];
+      if (!dockerPlatform) { log.warn(`unknown arch '${arch}' — skipped`); continue; }
+      const archImage = `${ROS2_DEV_IMAGE}-${arch}`;
+      ensureImage(archImage, { platform: dockerPlatform });
+      colconBuild(root, { symlink: false, arch });
+      log.ok(`dist/ros2_ws/install-${arch}/ ready`);
+    }
+  } else {
+    // rclpy / pure Python: arch-agnostic, build once
+    ensureImage();
+    colconBuild(root, { symlink: false });
+    log.ok("dist/ros2_ws/install/ ready");
+  }
 }
 
 // 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. 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 = ["x86_64", "aarch64"]) {
+export async function exportCppBuild(root, distDir, archs = ["amd64", "arm64"]) {
   if (manifestRuntime(root) !== "cpp") return;
-  const { assertDockerReady, ensureImage, cmakeBuild } = await import("./cpp.mjs");
+  const { assertDockerReady, ensureImage, cmakeBuild, CPP_DEV_IMAGE, ARCH_DOCKER_PLATFORM } = await import("./cpp.mjs");
   try {
     assertDockerReady();
   } catch (e) {
     log.warn(`cpp build skipped: ${e.message}`);
     return;
   }
-  ensureImage();
 
   const entry = JSON.parse(readFileSync(resolve(root, "manifest.json"), "utf8")).runtime?.entry;
   if (!entry) {
@@ -107,6 +115,11 @@ export async function exportCppBuild(root, distDir, archs = ["x86_64", "aarch64"
   }
 
   for (const arch of archs) {
+    // python과 동일하게 arch별 이미지를 빌드해야 --platform 불일치를 피할 수 있다.
+    const dockerPlatform = ARCH_DOCKER_PLATFORM[arch];
+    if (!dockerPlatform) { log.warn(`unknown arch '${arch}' — skipped`); continue; }
+    const archImage = `${CPP_DEV_IMAGE}-${arch}`;
+    ensureImage(archImage, { platform: dockerPlatform });
     cmakeBuild(root, { buildType: "Release", arch });
     const buildDir = `cpp/build-${arch}`;
     const built = resolve(root, buildDir, entry);
@@ -259,18 +272,7 @@ export async function buildPlugin({ root, minify = false } = {}) {
   return { pluginRoot, distDir };
 }
 
-function dirSize(dir) {
-  let total = 0;
-  for (const entry of readdirSync(dir)) {
-    const full = resolve(dir, entry);
-    const st = statSync(full);
-    total += st.isDirectory() ? dirSize(full) : st.size;
-  }
-  return total;
-}
-
-// Recursively sum directory size, skipping subdirs in `skip` list (by name).
-function dirSizeExcluding(dir, skip = []) {
+function dirSize(dir, skip = []) {
   if (!existsSync(dir)) return 0;
   let total = 0;
   for (const entry of readdirSync(dir)) {
@@ -284,57 +286,15 @@ function dirSizeExcluding(dir, skip = []) {
 
 // Read the uncompressed byte total of a .whl (zip) file by parsing its central
 // directory — no external library needed, no actual extraction.
-function unpackedWheelSize(whlPath) {
-  const buf = readFileSync(whlPath);
-  // Find EOCD signature (0x06054b50) scanning from end
-  let eocd = -1;
-  for (let i = buf.length - 22; i >= Math.max(0, buf.length - 65558); i--) {
-    if (buf.readUInt32LE(i) === 0x06054b50) { eocd = i; break; }
-  }
-  if (eocd === -1) return 0;
-  const cdOffset = buf.readUInt32LE(eocd + 16);
-  const cdSize   = buf.readUInt32LE(eocd + 12);
-  let pos = cdOffset;
-  let total = 0;
-  while (pos < cdOffset + cdSize) {
-    if (buf.readUInt32LE(pos) !== 0x02014b50) break; // central dir signature
-    total += buf.readUInt32LE(pos + 24); // uncompressed size
-    const fnLen      = buf.readUInt16LE(pos + 28);
-    const extraLen   = buf.readUInt16LE(pos + 30);
-    const commentLen = buf.readUInt16LE(pos + 32);
-    pos += 46 + fnLen + extraLen + commentLen;
-  }
-  return total;
-}
 
-// Calculate max(arch installedSize) across requested archs and stamp it into
-// both manifest.json (root) and dist/manifest.json.
-// installedSize(arch) = dist/(excl. wheels/) + ros2_ws/install/ + uncompressed arch+none-any wheels
-function calcInstalledSize(pluginRoot, archs) {
-  const distDir     = resolve(pluginRoot, "dist");
-  const wheelsDir   = resolve(distDir, "wheels");
-  const ros2Install = resolve(pluginRoot, "ros2_ws/install");
-
-  const baseSize = dirSizeExcluding(distDir, ["wheels"]);
-  const ros2Size = existsSync(ros2Install) ? dirSize(ros2Install) : 0;
-
-  // Collect all wheel files once
-  const wheels = existsSync(wheelsDir)
-    ? readdirSync(wheelsDir).filter((f) => f.endsWith(".whl")).map((f) => resolve(wheelsDir, f))
-    : [];
-
-  const perArchSize = archs.map((arch) => {
-    const archWheels = wheels.filter((w) => {
-      const name = w.split("/").pop();
-      // none-any wheels count for every arch
-      if (name.endsWith("none-any.whl")) return true;
-      return name.includes(arch);
-    });
-    const wheelSize = archWheels.reduce((sum, w) => sum + unpackedWheelSize(w), 0);
-    return baseSize + ros2Size + wheelSize;
-  });
+// installedSize = "이 플러그인 하나를 지우면 되찾는 용량"
+//   = dist/(wheels/ 제외)
+// ros2_ws/install* 은 이제 dist/ 안에 있으므로 별도 합산 불필요.
+// 휠은 로봇 공유 스토어(store/py/)에 언팩되므로 포함하지 않는다.
+function calcInstalledSize(pluginRoot) {
+  const distDir = resolve(pluginRoot, "dist");
 
-  const installedSize = Math.max(0, ...perArchSize);
+  const installedSize = dirSize(distDir, ["wheels"]);
 
   // Write to root manifest.json
   const rootManifestPath = resolve(pluginRoot, "manifest.json");
@@ -352,10 +312,11 @@ function calcInstalledSize(pluginRoot, archs) {
     writeFileSync(distManifestPath, JSON.stringify(m, null, 2) + "\n");
   }
 
-  log.ok(`installedSize → ${humanSize(installedSize)} (${archs.join(", ")} max, uncompressed)`);
+  log.ok(`installedSize → ${humanSize(installedSize)}`);
 }
 
-// Zip dist/ (+ ros2_ws/install) into a distributable ZIP with a size report.
+// Zip dist/ into a distributable ZIP with a size report.
+// ros2_ws/install* is now inside dist/, so only "dist" is needed.
 function packZip(pluginRoot) {
   const manifest = JSON.parse(readFileSync(resolve(pluginRoot, "manifest.json"), "utf8"));
   const zipName = `${basename(pluginRoot)}-${manifest.version || "0.0.0"}.zip`;
@@ -363,7 +324,6 @@ function packZip(pluginRoot) {
   rmSync(zipPath, { force: true });
 
   const entries = ["dist"];
-  if (existsSync(resolve(pluginRoot, "ros2_ws/install"))) entries.push("ros2_ws/install");
 
   log.step(`packing ${entries.join(", ")} → ${zipName}`);
   try {
@@ -387,27 +347,34 @@ function packZip(pluginRoot) {
 /**
  * Ask which target arch(es) to build for.
  * Non-TTY (CI): auto-selects current machine arch.
- * @returns {Promise<string[]>} e.g. ['x86_64'] | ['aarch64'] | ['x86_64','aarch64']
+ * @returns {Promise<string[]>} e.g. ['amd64'] | ['arm64'] | ['amd64','arm64']
  */
-async function promptArch() {
+async function promptArch(args = []) {
+  const archFlag = parseArgs(args).arch ?? null;
+  if (archFlag) {
+    if (archFlag === "both") return ["amd64", "arm64"];
+    if (archFlag === "amd64" || archFlag === "x86_64") return ["amd64"];
+    if (archFlag === "arm64" || archFlag === "aarch64") return ["arm64"];
+    throw new Error(`unknown --arch value '${archFlag}' (valid: amd64, arm64, both)`);
+  }
   if (!process.stdin.isTTY) {
     const { arch } = await import("node:os");
-    const machine = arch() === "arm64" ? "aarch64" : "x86_64";
+    const machine = arch() === "arm64" ? "arm64" : "amd64";
     log.info(`arch auto-selected (non-TTY): ${machine}`);
     return [machine];
   }
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   process.stdout.write(
     "\n  Target arch:\n" +
-    "    1) amd64 (x86_64)\n" +
-    "    2) arm64 (aarch64)\n" +
+    "    1) amd64\n" +
+    "    2) arm64\n" +
     "    3) Both (fat ZIP)\n",
   );
   const answer = (await rl.question("  Select [1/2/3, default: 3]: ")).trim() || "3";
   rl.close();
-  if (answer === "1") return ["x86_64"];
-  if (answer === "2") return ["aarch64"];
-  return ["x86_64", "aarch64"];
+  if (answer === "1") return ["amd64"];
+  if (answer === "2") return ["arm64"];
+  return ["amd64", "arm64"];
 }
 
 async function promptVersion(root) {
@@ -437,7 +404,7 @@ export async function runBuild(args) {
   if (rt !== "none") ensureDocker();
 
   await promptVersion(root);
-  const archs = await promptArch();
+  const archs = await promptArch(args);
 
   const { pluginRoot, distDir } = await buildPlugin({ root, minify: true });
 
@@ -457,8 +424,8 @@ export async function runBuild(args) {
     }
   }
 
-  await exportRos2Build(root);
+  await exportRos2Build(root, archs);
   await exportCppBuild(root, distDir, archs);
-  calcInstalledSize(pluginRoot, archs);
+  calcInstalledSize(pluginRoot);
   if (!noZip) packZip(pluginRoot);
 }

package/cli/src/check-package.mjs

@@ -1,29 +1,13 @@
-import { execFileSync } from "node:child_process";
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
-const roots = [resolve(root, "cli"), resolve(root, "preview-host")];
-
-function* mjsFiles(dir) {
-  for (const entry of readdirSync(dir)) {
-    const full = resolve(dir, entry);
-    const stat = statSync(full);
-    if (stat.isDirectory()) {
-      if (entry === "dist" || entry === "runtime" || entry === "templates") {
-        continue;
-      }
-      yield* mjsFiles(full);
-    } else if (entry.endsWith(".mjs")) {
-      yield full;
-    }
-  }
-}
-
-for (const dir of roots) {
-  if (!existsSync(dir)) continue;
-  for (const file of mjsFiles(dir)) {
-    execFileSync(process.execPath, ["--check", file], { stdio: "inherit" });
-  }
+for (const dir of ["cli", "preview-host"]) {
+  if (!existsSync(resolve(root, dir))) continue;
+  execSync(
+    `find ${dir} -name '*.mjs' ! -path '*/dist/*' ! -path '*/runtime/*' ! -path '*/templates/*' -exec node --check {} +`,
+    { cwd: root, stdio: "inherit" },
+  );
 }

package/cli/src/cpp.mjs

@@ -21,11 +21,12 @@ export function assertDockerReady() {
 }
 
 /** Build the dev image from the kit's bundled Dockerfile (Docker layer-caches). */
-export function ensureImage(image = CPP_DEV_IMAGE) {
-  log.step(`docker build -t ${image} (first run is slow, then cached)…`);
+export function ensureImage(image = CPP_DEV_IMAGE, { platform = null } = {}) {
+  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.");
@@ -33,9 +34,9 @@ export function ensureImage(image = CPP_DEV_IMAGE) {
 }
 
 // Docker platform token for each target arch
-const ARCH_DOCKER_PLATFORM = {
-  x86_64: "linux/amd64",
-  aarch64: "linux/arm64",
+export const ARCH_DOCKER_PLATFORM = {
+  amd64: "linux/amd64",
+  arm64: "linux/arm64",
 };
 
 /**
@@ -47,9 +48,10 @@ const ARCH_DOCKER_PLATFORM = {
  */
 export function cmakeBuild(root, { image = CPP_DEV_IMAGE, buildType = "Debug", arch = null } = {}) {
   const buildDir = arch ? `cpp/build-${arch}` : "cpp/build";
-  const platformFlags = arch && ARCH_DOCKER_PLATFORM[arch]
-    ? ["--platform", ARCH_DOCKER_PLATFORM[arch]]
-    : [];
+  const dockerPlatform = arch ? ARCH_DOCKER_PLATFORM[arch] : null;
+  const platformFlags = dockerPlatform ? ["--platform", dockerPlatform] : [];
+  // arch 빌드 시 arch별 이미지 사용 (로컬 이미지와 platform 불일치 방지)
+  const actualImage = arch ? `${CPP_DEV_IMAGE}-${arch}` : image;
   const script = [
     `cmake -S cpp -B ${buildDir} -DCMAKE_BUILD_TYPE=${buildType}`,
     `cmake --build ${buildDir} -j`,
@@ -58,7 +60,7 @@ export function cmakeBuild(root, { image = CPP_DEV_IMAGE, buildType = "Debug", a
   log.step(label);
   const r = spawnSync(
     "docker",
-    ["run", "--rm", ...platformFlags, "-v", `${root}:/plugin`, "-w", "/plugin", image, "bash", "-lc", script],
+    ["run", "--rm", ...platformFlags, "-v", `${root}:/plugin`, "-w", "/plugin", actualImage, "bash", "-lc", script],
     { cwd: root, stdio: "inherit" },
   );
   if (r.status !== 0) throw new Error(`cmake build failed${arch ? ` (${arch})` : ""}.`);

package/cli/src/devBack.mjs

@@ -8,10 +8,10 @@
 //   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, readFileSync, watch } from "node:fs";
+import { existsSync, watch } from "node:fs";
 import { resolve } from "node:path";
 import { ensureDocker, findPluginRoot, log } from "./util.mjs";
-import { readManifest as readManifestSchema, validateManifest } from "./manifest.mjs";
+import { manifestRuntime, readManifest, validateManifest } from "./manifest.mjs";
 import {
   PYTHON_DEV_IMAGE,
   assertDockerReady as pyAssertDockerReady,
@@ -29,18 +29,6 @@ import {
   ensureImage as cppEnsureImage,
 } from "./cpp.mjs";
 
-function readManifest(root) {
-  try {
-    return JSON.parse(readFileSync(resolve(root, "manifest.json"), "utf8"));
-  } catch {
-    return {};
-  }
-}
-
-function manifestRuntime(root) {
-  return readManifest(root).runtime?.type ?? "python";
-}
-
 // ── python ────────────────────────────────────────────────────────────────────
 // Runs in a warm Ubuntu 24.04 + Python 3.12 container (matches the robot).
 // Under `muscat-pk dev`, it shares the bridge container's netns, so the SDK
@@ -245,7 +233,7 @@ function runCpp(root) {
 }
 
 function warnManifest(root) {
-  const manifest = readManifestSchema(root);
+  const manifest = readManifest(root);
   if (!manifest || Object.keys(manifest).length === 0) return;
   const errors = validateManifest(manifest);
   for (const e of errors) log.warn(`manifest.json: ${e}`);

package/cli/src/manifest.mjs

@@ -36,6 +36,10 @@ export function readManifest(root) {
   }
 }
 
+export function manifestRuntime(root) {
+  return readManifest(root)?.runtime?.type ?? "python";
+}
+
 function validateIcons(icons, errors) {
   if (icons === undefined || icons === null) {
     errors.push("icons is required");

package/cli/src/new.mjs

@@ -10,10 +10,9 @@ import {
   statSync,
   writeFileSync,
 } from "node:fs";
-import { createInterface } from "node:readline/promises";
 import { basename, resolve } from "node:path";
 import { rmSync } from "node:fs";
-import { hasBin, kitVersion, parseArgs, templatesDir, log } from "./util.mjs";
+import { hasBin, kitVersion, parseArgs, prompt, templatesDir, log } from "./util.mjs";
 
 // `--type` values map to a runtime descriptor. ros2 has a python (rclpy) and a
 // C++ (rclcpp) flavor; we expose them as distinct type choices for clarity.
@@ -41,14 +40,6 @@ export function runtimeForChoice(choice, slug) {
   }
 }
 
-async function prompt(question, fallback) {
-  if (!process.stdin.isTTY) return fallback;
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  const answer = (await rl.question(question)).trim();
-  rl.close();
-  return answer || fallback;
-}
-
 export function applyTokens(dir, tokens) {
   for (const entry of readdirSync(dir)) {
     const full = resolve(dir, entry);

package/cli/src/python.mjs

@@ -35,8 +35,8 @@ export function ensureImage(image = PYTHON_DEV_IMAGE, { platform = null } = {})
 // Docker --platform 플래그: 컨테이너를 target arch로 띄우면
 // pip이 glibc + arch를 자동 감지해 올바른 휠을 받는다.
 const ARCH_DOCKER_PLATFORM = {
-  x86_64: "linux/amd64",
-  aarch64: "linux/arm64",
+  amd64: "linux/amd64",
+  arm64: "linux/arm64",
 };
 
 /**

package/cli/src/ros2.mjs

@@ -30,12 +30,18 @@ export function assertDockerReady() {
   }
 }
 
+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 function ensureImage(image = ROS2_DEV_IMAGE, { platform = null } = {}) {
+  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.");
@@ -47,20 +53,42 @@ 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(),
+    `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, "-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/type.mjs

@@ -3,9 +3,8 @@
 //   Adds the matching backend overlay; never deletes existing user code
 //   (e.g. ros2_ws/ or cpp/ are left in place when switching away).
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { createInterface } from "node:readline/promises";
 import { basename, resolve } from "node:path";
-import { findPluginRoot, log } from "./util.mjs";
+import { findPluginRoot, log, prompt } from "./util.mjs";
 import {
   TYPE_CHOICES,
   applyTokens,
@@ -17,14 +16,6 @@ import {
 
 const TYPES = Object.keys(TYPE_CHOICES);
 
-async function prompt(question, fallback) {
-  if (!process.stdin.isTTY) return fallback;
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  const answer = (await rl.question(question)).trim();
-  rl.close();
-  return answer || fallback;
-}
-
 function readManifest(root) {
   const path = resolve(root, "manifest.json");
   if (!existsSync(path)) throw new Error(`manifest.json not found in ${root}`);

package/cli/src/update.mjs

@@ -10,12 +10,11 @@
 //
 // After updating the CLI itself, also bumps the plugin project's local deps
 // and migrates the project structure if it's outdated (src/ → ui/, root main.py → py/).
-import { createInterface } from "node:readline";
 import { execSync, spawn } from "node:child_process";
 import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
-import { findPluginRoot, KIT_PUBLISHED_NAME, kitVersion, log, parseArgs } from "./util.mjs";
+import { findPluginRoot, KIT_PUBLISHED_NAME, kitVersion, log, parseArgs, prompt } from "./util.mjs";
 
 const PLUGIN_UI_PACKAGE = "@rainbow-robotics/plugin-ui";
 const S3_BASE = "https://rainbow-deploy.s3.ap-northeast-2.amazonaws.com/muscat-plugin-kit";
@@ -135,13 +134,6 @@ function detectOldStructure(root) {
   return issues;
 }
 
-function prompt(question) {
-  return new Promise((resolve) => {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    rl.question(question, (answer) => { rl.close(); resolve(answer.trim()); });
-  });
-}
-
 async function migrateStructure(root, issues) {
   log.warn("This plugin project's structure is outdated:");
   for (const issue of issues) log.info("  • " + issue.desc);

package/cli/src/util.mjs

@@ -3,6 +3,7 @@ import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline/promises";
 
 /** True if an executable is on PATH (cross-platform). */
 export function hasBin(bin) {
@@ -65,6 +66,15 @@ export function parseArgs(args, { booleans = [] } = {}) {
   return out;
 }
 
+/** Prompt user for input. Returns trimmed answer or fallback (non-TTY or empty). */
+export async function prompt(question, fallback = "") {
+  if (!process.stdin.isTTY) return fallback;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = (await rl.question(question)).trim();
+  rl.close();
+  return answer || fallback;
+}
+
 /** Walk up from cwd to find the plugin project root (has manifest.json). */
 export function findPluginRoot(start = process.cwd()) {
   let dir = resolve(start);

package/package.json

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