@rainbow-robotics/muscat-plugin-kit 0.1.2-dev.41 → 0.1.2-dev.42

package/cli/src/build.mjs

@@ -75,27 +75,33 @@ function isMainBranch() {
 // 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;
+  if (manifestRuntime(root) !== "ros2") return [];
   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;
+    return [];
   }
 
   const manifest = JSON.parse(readFileSync(resolve(root, "manifest.json"), "utf8"));
   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) { log.warn(`unknown arch '${arch}' — skipped`); continue; }
+      if (!dockerPlatform) { log.warn(`unknown arch '${arch}' — skipped`); skipped.push(arch); continue; }
       const archImage = `${ROS2_DEV_IMAGE}-${arch}`;
-      await ensureImage(archImage, { platform: dockerPlatform });
-      colconBuild(root, { symlink: false, arch });
-      log.ok(`dist/ros2_ws/install-${arch}/ ready`);
+      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
@@ -103,6 +109,7 @@ 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
@@ -110,13 +117,13 @@ export async function exportRos2Build(root, archs = ["amd64", "arm64"]) {
 // 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");
   try {
     assertDockerReady();
   } catch (e) {
     log.warn(`cpp build skipped: ${e.message}`);
-    return;
+    return [];
   }
 
   const entry = JSON.parse(readFileSync(resolve(root, "manifest.json"), "utf8")).runtime?.entry;
@@ -125,26 +132,31 @@ export async function exportCppBuild(root, distDir, archs = ["amd64", "arm64"])
     return;
   }
 
+  const skipped = [];
   for (const arch of archs) {
-    // python과 동일하게 arch별 이미지를 빌드해야 --platform 불일치를 피할 수 있다.
     const dockerPlatform = ARCH_DOCKER_PLATFORM[arch];
-    if (!dockerPlatform) { log.warn(`unknown arch '${arch}' — skipped`); continue; }
+    if (!dockerPlatform) { log.warn(`unknown arch '${arch}' — skipped`); skipped.push(arch); continue; }
     const archImage = `${CPP_DEV_IMAGE}-${arch}`;
-    await ensureImage(archImage, { platform: dockerPlatform });
-    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}`);
+    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);
     }
   }
+  return skipped;
 }
 
 const PRERELEASE_RE = /\.(dev|a|b|rc|alpha|beta)\d*/i;
@@ -434,6 +446,8 @@ export async function runBuild(args) {
 
   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 ?? {};
@@ -443,15 +457,29 @@ export async function runBuild(args) {
     if (needsLock) {
       const { lockAndVendor } = await import("./python.mjs");
       try {
-        await lockAndVendor(pluginRoot, archs);
+        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/devUi.mjs

@@ -7,7 +7,7 @@ import { copyFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
 import { SANDBOX_HTML } from "./build.mjs";
-import { checkKitUpdate, findPluginRoot, hasBin, kitRoot, log } from "./util.mjs";
+import { checkKitUpdate, findPluginRoot, hasBin, kitRoot, log, parseArgs, prompt } from "./util.mjs";
 
 const PREVIEW_PKG = "@rainbow-robotics/preview-host";
 const CACHE_DIR = resolve(homedir(), ".muscat-pk");
@@ -79,7 +79,7 @@ function findViteBin(pluginRoot) {
 
 // Spawn vite build --watch as a background process.
 // Returns the child process, or null if vite/node not available.
-function spawnViteWatch(pluginRoot, node) {
+function spawnViteWatch(pluginRoot, node, { robotIp = "" } = {}) {
   const viteBin = findViteBin(pluginRoot);
   if (!node || !viteBin || !existsSync(viteBin)) return null;
 
@@ -87,6 +87,7 @@ function spawnViteWatch(pluginRoot, node) {
   return spawn(node, [viteBin, "build", "--watch", "--mode", "development", "--outDir", DEV_OUT], {
     cwd: pluginRoot,
     stdio: "inherit",
+    env: { ...process.env, ...(robotIp ? { VITE_RRS_PY_HOST: robotIp } : {}) },
   });
 }
 
@@ -105,15 +106,18 @@ function waitForInitialBuild(distDir, timeoutMs = 30_000) {
 }
 
 export async function runDevUi(args = []) {
-  const portIdx = args.indexOf("--port");
-  const port = portIdx !== -1 ? args[portIdx + 1] : "4180";
+  const parsed = parseArgs(args);
+  const port = parsed.port ?? "4180";
+  const robotIp = parsed["robot-ip"] ?? await prompt("  Robot IP (Enter to skip): ");
 
   await checkKitUpdate();
   const pluginRoot = findPluginRoot();
   const outDir = stageDevAssets(pluginRoot);
 
+  if (robotIp) log.info(`MUSCAT_API_ORIGIN → http://${robotIp}:*`);
+
   const node = findNodeBin();
-  const viteProc = spawnViteWatch(pluginRoot, node);
+  const viteProc = spawnViteWatch(pluginRoot, node, { robotIp });
 
   if (viteProc) {
     log.step("waiting for initial vite build…");

package/cli/src/python.mjs

@@ -27,22 +27,30 @@ export async function ensureImage(image = PYTHON_DEV_IMAGE, { platform = null }
   pruneMuskatImages();
 }
 
-// Docker --platform 플래그: 컨테이너를 target arch로 띄우면
-// pip이 glibc + arch를 자동 감지해 올바른 휠을 받는다.
-const ARCH_DOCKER_PLATFORM = {
-  amd64: "linux/amd64",
-  arm64: "linux/arm64",
+// pip --platform does NOT auto-expand manylinux tags (unlike sys_tags()) — exact match only.
+// Specifying all common glibc milestones ensures packages built for any Ubuntu era are found.
+const PIP_PLATFORM = {
+  amd64: [
+    "manylinux_2_5_x86_64",
+    "manylinux_2_17_x86_64",
+    "manylinux_2_27_x86_64",
+    "manylinux_2_28_x86_64",
+    "manylinux_2_34_x86_64",
+    "manylinux_2_39_x86_64",
+    "linux_x86_64",
+  ],
+  arm64: [
+    "manylinux_2_17_aarch64",
+    "manylinux_2_27_aarch64",
+    "manylinux_2_28_aarch64",
+    "manylinux_2_34_aarch64",
+    "manylinux_2_39_aarch64",
+    "linux_aarch64",
+  ],
 };
 
-/**
- * Ubuntu 24.04 + py3.12 컨테이너 안에서:
- *   1. uv pip compile requirements.txt → dist/requirements.lock  (arch 무관, 1회)
- *   2. archs별 pip download --platform <manylinux_tag> → dist/wheels/  (네이티브 휠 벤더링)
- *
- * none-any 휠은 pip이 두 번째 arch에서 자동 skip → 중복 없음.
- * requirements.txt 없으면 조용히 건너뜀.
- */
-export async function lockAndVendor(pluginRoot, archs = ["x86_64", "aarch64"]) {
+export async function lockAndVendor(pluginRoot, archs = ["amd64", "arm64"]) {
+  // ponytail: pip --platform used intentionally (not QEMU) — downloads wheels without running target arch code.
   const reqTxt = resolve(pluginRoot, "requirements.txt");
   if (!existsSync(reqTxt)) {
     log.warn("requirements.txt not found — lock/vendor skipped");
@@ -66,45 +74,28 @@ export async function lockAndVendor(pluginRoot, archs = ["x86_64", "aarch64"]) {
   if (lockResult.status !== 0) throw new Error("lock generation failed (uv pip compile)");
   log.ok("dist/requirements.lock ready");
 
-  // arch별 휠 벤더링 — QEMU 불필요 (download only, --platform 고정)
-  // 한 arch가 실패해도 나머지 arch는 계속 시도한다.
   const failed = [];
   for (const arch of archs) {
-    const dockerPlatform = ARCH_DOCKER_PLATFORM[arch];
-    if (!dockerPlatform) {
-      log.warn(`unknown arch '${arch}' — skipped`);
-      continue;
-    }
-    // arch별 이미지 빌드 (--platform 지정) → pip이 glibc+arch 자동 감지 → 올바른 휠 선택.
-    const archImage = `${PYTHON_DEV_IMAGE}-${arch}`;
-    await ensureImage(archImage, { platform: dockerPlatform });
-
-    log.step(`vendoring wheels for ${arch} (${dockerPlatform})…`);
-    // 패키지별 개별 download로 private/미공개 패키지 실패 시에도 나머지 계속 진행.
-    const script = [
-      `set -e`,
-      `cd /plugin`,
-      `mkdir -p dist/wheels`,
-      `pkgs=$(grep -v '^#' dist/requirements.lock | grep -v '^[[:space:]]' | grep -v '^$')`,
-      `SKIP=""`,
-      `for pkg in $pkgs; do`,
-      `  pip3 download "$pkg" --no-deps --only-binary=:all: -d dist/wheels -q 2>&1 || SKIP="$SKIP $pkg"`,
-      `done`,
-      `[ -z "$SKIP" ] || echo "WARN: no wheel found (package not on PyPI or missing binary wheel):$SKIP"`,
-    ].join("\n");
+    const pipPlatforms = PIP_PLATFORM[arch];
+    if (!pipPlatforms) { log.warn(`unknown arch '${arch}' — skipped`); continue; }
+    log.step(`vendoring wheels for ${arch}…`);
     const r = spawnSync(
       "docker",
       [
         "run", "--rm",
-        "--platform", dockerPlatform,
+        "-e", "PIP_ROOT_USER_ACTION=ignore",
         "-v", `${pluginRoot}:/plugin`,
-        archImage,
-        "bash", "-c", script,
+        "-w", "/plugin",
+        PYTHON_DEV_IMAGE,
+        "bash", "-c",
+        "mkdir -p dist/wheels && pip3 download -r dist/requirements.lock --no-deps --only-binary=:all: -d dist/wheels -q " +
+          "--python-version 312 --implementation cp --abi cp312 " +
+          pipPlatforms.map((p) => `--platform ${p}`).join(" "),
       ],
       { stdio: "inherit" },
     );
     if (r.status !== 0) {
-      log.warn(`wheel vendoring failed for ${arch} — some packages may not have manylinux wheels`);
+      log.warn(`wheel vendoring failed for ${arch}`);
       failed.push(arch);
     } else {
       log.ok(`dist/wheels/ ready (${arch})`);
@@ -114,9 +105,5 @@ export async function lockAndVendor(pluginRoot, archs = ["x86_64", "aarch64"]) {
   if (failed.length === archs.length) {
     throw new Error(`wheel vendoring failed for all archs: ${failed.join(", ")}`);
   }
-  if (failed.length > 0) {
-    log.warn(`wheel vendoring partial — failed: ${failed.join(", ")}, ok: ${archs.filter((a) => !failed.includes(a)).join(", ")}`);
-  } else {
-    log.ok(`dist/wheels/ ready (${archs.join(", ")})`);
-  }
+  return failed;
 }

package/package.json

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