@rainbow-robotics/muscat-plugin-kit 0.1.2-dev.29 → 0.1.2-dev.30

package/cli/src/build.mjs

@@ -85,10 +85,11 @@ export async function exportRos2Build(root) {
   log.ok("ros2_ws/install ready (will be included in the ZIP)");
 }
 
-// For cpp plugins, compile cpp/ inside the Ubuntu container (Release) and copy
-// the binary into dist/ so the ZIP carries a robot-compatible executable.
-// Skipped (with a warning) if Docker is unavailable.
-export async function exportCppBuild(root, distDir) {
+// 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"]) {
   if (manifestRuntime(root) !== "cpp") return;
   const { assertDockerReady, ensureImage, cmakeBuild } = await import("./cpp.mjs");
   try {
@@ -98,17 +99,27 @@ export async function exportCppBuild(root, distDir) {
     return;
   }
   ensureImage();
-  cmakeBuild(root, { buildType: "Release" });
 
   const entry = JSON.parse(readFileSync(resolve(root, "manifest.json"), "utf8")).runtime?.entry;
-  const built = resolve(root, "cpp/build", entry ?? "");
-  if (entry && existsSync(built)) {
-    const dest = resolve(distDir, entry);
-    copyFileSync(built, dest);
-    chmodSync(dest, 0o755);
-    log.ok(`cpp binary → dist/${entry} (will be included in the ZIP)`);
-  } else {
-    log.warn(`cpp binary not found at cpp/build/${entry} — skipped`);
+  if (!entry) {
+    log.warn("manifest.json runtime.entry not set — cpp build skipped");
+    return;
+  }
+
+  for (const arch of archs) {
+    cmakeBuild(root, { buildType: "Release", arch });
+    const buildDir = `cpp/build-${arch}`;
+    const built = resolve(root, buildDir, 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 ${buildDir}/${entry} — skipped for ${arch}`);
+    }
   }
 }
 
@@ -258,6 +269,92 @@ function dirSize(dir) {
   return total;
 }
 
+// Recursively sum directory size, skipping subdirs in `skip` list (by name).
+function dirSizeExcluding(dir, skip = []) {
+  if (!existsSync(dir)) return 0;
+  let total = 0;
+  for (const entry of readdirSync(dir)) {
+    if (skip.includes(entry)) continue;
+    const full = resolve(dir, entry);
+    const st = statSync(full);
+    total += st.isDirectory() ? dirSize(full) : st.size;
+  }
+  return total;
+}
+
+// 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;
+  });
+
+  const installedSize = Math.max(0, ...perArchSize);
+
+  // Write to root manifest.json
+  const rootManifestPath = resolve(pluginRoot, "manifest.json");
+  if (existsSync(rootManifestPath)) {
+    const m = JSON.parse(readFileSync(rootManifestPath, "utf8"));
+    m.installedSize = installedSize;
+    writeFileSync(rootManifestPath, JSON.stringify(m, null, 2) + "\n");
+  }
+
+  // Re-stage dist/manifest.json so the ZIP carries the updated value
+  const distManifestPath = resolve(distDir, "manifest.json");
+  if (existsSync(distManifestPath)) {
+    const m = JSON.parse(readFileSync(distManifestPath, "utf8"));
+    m.installedSize = installedSize;
+    writeFileSync(distManifestPath, JSON.stringify(m, null, 2) + "\n");
+  }
+
+  log.ok(`installedSize → ${humanSize(installedSize)} (${archs.join(", ")} max, uncompressed)`);
+}
+
 // Zip dist/ (+ ros2_ws/install) into a distributable ZIP with a size report.
 function packZip(pluginRoot) {
   const manifest = JSON.parse(readFileSync(resolve(pluginRoot, "manifest.json"), "utf8"));
@@ -354,7 +451,7 @@ export async function runBuild(args) {
     if (needsLock) {
       const { lockAndVendor } = await import("./python.mjs");
       try {
-        lockAndVendor(pluginRoot);
+        lockAndVendor(pluginRoot, archs);
       } catch (e) {
         log.warn(`python lock/vendor skipped: ${e.message}`);
       }
@@ -362,6 +459,7 @@ export async function runBuild(args) {
   }
 
   await exportRos2Build(root);
-  await exportCppBuild(root, distDir);
+  await exportCppBuild(root, distDir, archs);
+  calcInstalledSize(pluginRoot, archs);
   if (!noZip) packZip(pluginRoot);
 }

package/cli/src/cpp.mjs

@@ -32,21 +32,34 @@ export function ensureImage(image = CPP_DEV_IMAGE) {
   pruneMuskatImages();
 }
 
+// Docker platform token for each target arch
+const ARCH_DOCKER_PLATFORM = {
+  x86_64: "linux/amd64",
+  aarch64: "linux/arm64",
+};
+
 /**
- * Configure + build cpp/ inside the container, producing cpp/build/<entry> on
- * the host (the workspace is mounted). buildType "Debug" for dev, "Release" for
- * export builds that ship in the ZIP.
+ * Configure + build cpp/ inside the container, producing cpp/build-{arch}/<entry>
+ * on the host (the workspace is mounted).
+ * - arch null → native (dev mode, uses cpp/build/)
+ * - arch "x86_64" / "aarch64" → cross via --platform (Release builds for ZIP)
+ * buildType "Debug" for dev, "Release" for export builds that ship in the ZIP.
  */
-export function cmakeBuild(root, { image = CPP_DEV_IMAGE, buildType = "Debug" } = {}) {
+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 script = [
-    `cmake -S cpp -B cpp/build -DCMAKE_BUILD_TYPE=${buildType}`,
-    "cmake --build cpp/build -j",
+    `cmake -S cpp -B ${buildDir} -DCMAKE_BUILD_TYPE=${buildType}`,
+    `cmake --build ${buildDir} -j`,
   ].join(" && ");
-  log.step(`cmake build (${buildType}, in container)…`);
+  const label = arch ? `cmake build (${buildType}, ${arch}, in container)…` : `cmake build (${buildType}, in container)…`;
+  log.step(label);
   const r = spawnSync(
     "docker",
-    ["run", "--rm", "-v", `${root}:/plugin`, "-w", "/plugin", image, "bash", "-lc", script],
+    ["run", "--rm", ...platformFlags, "-v", `${root}:/plugin`, "-w", "/plugin", image, "bash", "-lc", script],
     { cwd: root, stdio: "inherit" },
   );
-  if (r.status !== 0) throw new Error("cmake build failed.");
+  if (r.status !== 0) throw new Error(`cmake build failed${arch ? ` (${arch})` : ""}.`);
 }

package/cli/src/python.mjs

@@ -31,16 +31,21 @@ export function ensureImage(image = PYTHON_DEV_IMAGE) {
   pruneMuskatImages();
 }
 
+// manylinux tag that matches each target arch for pip --platform
+const ARCH_PLATFORM = {
+  x86_64: "manylinux2014_x86_64",
+  aarch64: "manylinux2014_aarch64",
+};
+
 /**
  * Ubuntu 24.04 + py3.12 컨테이너 안에서:
- *   1. uv pip compile requirements.txt → dist/requirements.lock  (전이 포함 완전 lock)
- *   2. pip download -r dist/requirements.lock → dist/wheels/     (타겟 플랫폼 휠 벤더링)
+ *   1. uv pip compile requirements.txt → dist/requirements.lock  (arch 무관, 1회)
+ *   2. archs별 pip download --platform <manylinux_tag> → dist/wheels/  (네이티브 휠 벤더링)
  *
- * 컨테이너 arch = 빌드 머신 arch = 로봇 arch 가 동일해야 네이티브 휠이 일치한다.
- * 순수 Python 패키지(py3-none-any)는 arch 무관.
+ * none-any 휠은 pip이 두 번째 arch에서 자동 skip → 중복 없음.
  * requirements.txt 없으면 조용히 건너뜀.
  */
-export function lockAndVendor(pluginRoot) {
+export function lockAndVendor(pluginRoot, archs = ["x86_64", "aarch64"]) {
   const reqTxt = resolve(pluginRoot, "requirements.txt");
   if (!existsSync(reqTxt)) {
     log.warn("requirements.txt not found — lock/vendor skipped");
@@ -64,18 +69,29 @@ export function lockAndVendor(pluginRoot) {
   if (lockResult.status !== 0) throw new Error("lock generation failed (uv pip compile)");
   log.ok("dist/requirements.lock ready");
 
-  log.step("vendoring wheels (pip download)…");
-  const vendorResult = spawnSync(
-    "docker",
-    [
-      "run", "--rm",
-      "-v", `${pluginRoot}:/plugin`,
-      PYTHON_DEV_IMAGE,
-      "bash", "-c",
-      "set -e && cd /plugin && mkdir -p dist/wheels && pip3 download -r dist/requirements.lock --only-binary=:all: -d dist/wheels",
-    ],
-    { stdio: "inherit" },
-  );
-  if (vendorResult.status !== 0) throw new Error("wheel vendoring failed (pip download)");
-  log.ok("dist/wheels/ ready");
+  // arch별 휠 벤더링 — QEMU 불필요 (download only, --platform 고정)
+  for (const arch of archs) {
+    const platform = ARCH_PLATFORM[arch];
+    if (!platform) {
+      log.warn(`unknown arch '${arch}' — skipped`);
+      continue;
+    }
+    log.step(`vendoring wheels for ${arch} (${platform})…`);
+    const r = spawnSync(
+      "docker",
+      [
+        "run", "--rm",
+        "-v", `${pluginRoot}:/plugin`,
+        PYTHON_DEV_IMAGE,
+        "bash", "-c",
+        `set -e && cd /plugin && mkdir -p dist/wheels && ` +
+        `pip3 download -r dist/requirements.lock ` +
+        `--only-binary=:all: --platform ${platform} --python-version 312 --implementation cp ` +
+        `-d dist/wheels`,
+      ],
+      { stdio: "inherit" },
+    );
+    if (r.status !== 0) throw new Error(`wheel vendoring failed for ${arch}`);
+  }
+  log.ok(`dist/wheels/ ready (${archs.join(", ")})`);
 }

package/package.json

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