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

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

@@ -68,37 +68,53 @@ function manifestRuntime(root) {
   }
 }
 
-// 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 +123,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);
@@ -284,57 +305,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 = dirSizeExcluding(distDir, ["wheels"]);
 
   // Write to root manifest.json
   const rootManifestPath = resolve(pluginRoot, "manifest.json");
@@ -352,10 +331,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 +343,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 +366,36 @@ 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 = []) {
+  // --arch x86_64 | --arch aarch64 | --arch both
+  const archFlag = args.find((a) => a.startsWith("--arch="))?.slice(7)
+    ?? (args.includes("--arch") ? args[args.indexOf("--arch") + 1] : 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 +425,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 +445,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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rainbow-robotics/muscat-plugin-kit",
-  "version": "0.1.2-dev.34",
+  "version": "0.1.2-dev.35",
   "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.35",
     "socket.io": "^4.8.1"
   },
   "optionalDependencies": {