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

package/cli/src/ports.mjs

@@ -4,15 +4,7 @@ import { usesHostNetwork } from "./zenohDev.mjs";
 
 export const PLUGIN_PORT_MIN = 28600;
 export const PLUGIN_PORT_MAX = 28999;
-export const MEDIA_PORTS = [8554, 8889, 8189]; // MediaMTX: RTSP publish, WebRTC, WebRTC media
-export const INTERNAL_DEV_PORTS = new Set([10000, ...MEDIA_PORTS]);
-
-export function mediaPortFlags() {
-  return [
-    "-p", "127.0.0.1:8554:8554", "-p", "127.0.0.1:8889:8889",
-    "-p", "127.0.0.1:8189:8189/udp", "-p", "127.0.0.1:8189:8189/tcp",
-  ];
-}
+export const INTERNAL_DEV_PORTS = new Set([10000]);
 export const RESERVED_BACKEND_PORTS = new Map([
   [502, "Modbus TCP"],
   [4840, "OPC-UA"],
@@ -126,21 +118,14 @@ export function publishPortFlags(ranges = []) {
   return ranges.flatMap((port) => ["-p", `127.0.0.1:${port}:${port}`]);
 }
 
-// Skips OS-assigned loopback listeners (127.0.0.1:0, e.g. the SDK's Zenoh session).
 function listeningTcpPorts(container) {
   const script = `
-read -r eph_lo eph_hi < /proc/sys/net/ipv4/ip_local_port_range 2>/dev/null || { eph_lo=32768; eph_hi=60999; }
 for f in /proc/net/tcp /proc/net/tcp6; do
   [ -r "$f" ] || continue
   tail -n +2 "$f" | while read -r sl local_address rem_address st rest; do
     [ "$st" = "0A" ] || continue
-    hex_ip="\${local_address%%:*}"
-    port=$((0x\${local_address##*:}))
-    case "$hex_ip" in
-      0100007F|00000000000000000000000001000000)
-        [ "$port" -ge "$eph_lo" ] && [ "$port" -le "$eph_hi" ] && continue ;;
-    esac
-    echo "$port"
+    hex_port="\${local_address##*:}"
+    printf "%d\\n" "0x$hex_port"
   done
 done | sort -n -u
 `;
@@ -156,9 +141,10 @@ done | sort -n -u
 }
 
 export function startPortContractMonitor({ container, ranges, log, intervalMs = 1000, allow = [] }) {
-  // Under --network host (or a local Muscat container's netns) /proc/net/tcp shows every
-  // host/robot service port, not just the plugin's — the contract can't be enforced.
-  if (usesHostNetwork() || process.env.MUSCAT_PK_MUSCAT_CONTAINER) return () => false;
+  // Under --network host the container shares the host's netns, so
+  // /proc/net/tcp shows every host/robot service port, not just the plugin's —
+  // the contract can't be enforced. Skip it (no isolated ports to police).
+  if (usesHostNetwork()) return () => false;
   const declared = ranges ?? [];
   // muscat-pk's own dev plumbing shares this netns — not the plugin's doing.
   const ignored = new Set([...INTERNAL_DEV_PORTS, ...allow.map(Number).filter(Number.isInteger)]);

package/cli/src/python.mjs

@@ -1,9 +1,9 @@
 // Shared Python Docker helpers (Ubuntu 24.04 + Python 3.12 — matches the robot).
 // Used by dev:back (hot-reload) and build (lock + wheel vendor).
 import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { dirname, resolve } 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 PYTHON_DEV_IMAGE = "muscat-pk-python-dev";
 
@@ -15,17 +15,16 @@ export function assertDockerReady() {
 
 /** Build the dev image from the kit's bundled Dockerfile (Docker layer-caches). */
 export async function ensureImage(image = PYTHON_DEV_IMAGE, { platform = null } = {}) {
-  const dockerfile = await resolveDockerfile("Dockerfile.python");
-  const key = imageKey(dockerfile);
-  if (canSkipImageBuild(image, key)) {
+  if (canSkipImageBuild(image)) {
     log.step(`${image} already built — skipping docker build`);
     return;
   }
+  const dockerfile = await resolveDockerfile("Dockerfile.python");
   log.step(`docker build -t ${image}${platform ? ` (${platform})` : ""} (first run is slow, then cached)…`);
   const platformFlags = platform ? ["--platform", platform] : [];
   const r = spawnSync(
     "docker",
-    ["build", ...platformFlags, ...imageKeyLabel(key), "-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.");
@@ -66,11 +65,7 @@ export async function lockAndVendor(pluginRoot, archs = ["amd64", "arm64"]) {
 
   await ensureImage();
 
-  // A pinned pre-release (e.g. rainbow-rb-sdk==0.1.4.dev1) pins its sibling rainbow-rb-*
-  // pre-releases too; uv rejects those transitive pre-releases unless allowed.
-  const reqText = readFileSync(resolve(pluginRoot, "requirements.txt"), "utf8");
-  const prerelease = /==\s*\S*\d(a|b|rc|\.dev)\d*\s*$/im.test(reqText) ? " --prerelease=allow" : "";
-  log.step(`generating lock (uv pip compile${prerelease})…`);
+  log.step("generating lock (uv pip compile)…");
   const lockResult = spawnSync(
     "docker",
     [
@@ -79,16 +74,17 @@ export async function lockAndVendor(pluginRoot, archs = ["amd64", "arm64"]) {
       "-v", `${pluginRoot}:/plugin`,
       PYTHON_DEV_IMAGE,
       "bash", "-c",
-      "set -e && cd /plugin && mkdir -p dist && uv pip compile requirements.txt --python-version 3.12 -o dist/requirements.lock" + prerelease,
+      "set -e && cd /plugin && mkdir -p dist && uv pip compile requirements.txt --python-version 3.12 -o dist/requirements.lock",
     ],
     { stdio: "inherit" },
   );
   if (lockResult.status !== 0) throw new Error("lock generation failed (uv pip compile)");
   log.ok("dist/requirements.lock ready");
 
+  const failed = [];
   for (const arch of archs) {
     const pipPlatforms = PIP_PLATFORM[arch];
-    if (!pipPlatforms) throw new Error(`unknown arch '${arch}'`);
+    if (!pipPlatforms) { log.warn(`unknown arch '${arch}' — skipped`); continue; }
     log.step(`vendoring wheels for ${arch}…`);
     const r = spawnSync(
       "docker",
@@ -106,8 +102,16 @@ export async function lockAndVendor(pluginRoot, archs = ["amd64", "arm64"]) {
       ],
       { stdio: "inherit" },
     );
-    // A ZIP missing wheels fails to import on the robot — stop instead.
-    if (r.status !== 0) throw new Error(`wheel download failed for ${arch} (see pip output above)`);
-    log.ok(`dist/wheels/ ready (${arch})`);
+    if (r.status !== 0) {
+      log.warn(`wheel vendoring failed for ${arch}`);
+      failed.push(arch);
+    } else {
+      log.ok(`dist/wheels/ ready (${arch})`);
+    }
+  }
+
+  if (failed.length === archs.length) {
+    throw new Error(`wheel vendoring failed for all archs: ${failed.join(", ")}`);
   }
+  return failed;
 }

package/cli/src/ros2.mjs

@@ -3,7 +3,7 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { canSkipImageBuild, imageKey, imageKeyLabel, dockerUserFlags, hasBin, log, pruneMuskatImages, resolveDockerfile } from "./util.mjs";
+import { canSkipImageBuild, hasBin, log, pruneMuskatImages, resolveDockerfile } from "./util.mjs";
 
 export const ROS2_DEV_IMAGE = "muscat-pk-ros2-dev";
 
@@ -30,19 +30,16 @@ export const ARCH_DOCKER_PLATFORM = {
 
 /** Build the dev image from the kit's bundled Dockerfile (Docker layer-caches). */
 export async function ensureImage(image = ROS2_DEV_IMAGE, { platform = null } = {}) {
-  const dockerfile = await resolveDockerfile("Dockerfile.dev");
-  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.dev");
   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.");
@@ -74,16 +71,12 @@ export function colconBuild(root, { image = ROS2_DEV_IMAGE, symlink = false, arc
     installBase = "../dist/ros2_ws/install";
   }
   const flag = symlink ? "--symlink-install" : "";
-  const buildBase = symlink ? "build" : arch ? `build-${arch}` : "build-dist";
   const script = [
     "pip install -r requirements.txt --break-system-packages --ignore-installed -q || true",
     "cd ros2_ws",
-    // Export builds use their own build cache: sharing build/ with dev's --symlink-install
-    // (or another arch) breaks the next colcon build.
-    // rclcpp export: ship librb_sdk.so in <pkg>/lib/ (robot has no SDK) when the node links it.
-    `colcon build ${flag} --build-base ${buildBase} --install-base ${installBase}`.replace("  ", " ") +
-      (arch ? ` --cmake-args '-DCMAKE_INSTALL_RPATH=$ORIGIN/..'` : ""),
-    ...(arch ? [`for d in ${installBase}/*/lib; do if readelf -d $(find "$d" -mindepth 2 -type f -executable) 2>/dev/null | grep -q librb_sdk; then cp -a $(dpkg -L rainbow-rb-sdk | grep -E '/librb_sdk[.]so[.][0-9]') "$d"/; fi; done`] : []),
+    // ponytail: rm only on cross-arch; same-arch dev rebuilds keep the cache
+    ...(arch ? ["rm -rf build"] : []),
+    `colcon build ${flag} --install-base ${installBase}`.trim(),
   ].join(" && ");
   const label = arch
     ? `colcon build (${arch}) → dist/ros2_ws/install-${arch}/…`
@@ -94,8 +87,7 @@ export function colconBuild(root, { image = ROS2_DEV_IMAGE, symlink = false, arc
   const platformFlags = dockerPlatform ? ["--platform", dockerPlatform] : [];
   const r = spawnSync(
     "docker",
-    // python/cpp 와 같이 호스트 uid 로 돌린다 — root 소유 산출물이 남으면 사용자가 지우지 못한다.
-    ["run", "--rm", ...platformFlags, ...dockerUserFlags(), "-e", "PIP_ROOT_USER_ACTION=ignore", "-v", `${root}:/plugin`, "-w", "/plugin", actualImage, "bash", "-lc", script],
+    ["run", "--rm", ...platformFlags, "-e", "PIP_ROOT_USER_ACTION=ignore", "-v", `${root}:/plugin`, "-w", "/plugin", actualImage, "bash", "-lc", script],
     { cwd: root, stdio: "inherit" },
   );
   if (r.status !== 0) throw new Error(`colcon build failed${arch ? ` (${arch})` : ""}.`);

package/cli/src/sdk.mjs

@@ -6,24 +6,24 @@
 // the new version immediately; this is best-effort only.
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { ensureIdeVenv, findPluginRoot, log, venvPython } from "./util.mjs";
+import { spawnSync } from "node:child_process";
+import { findPluginRoot, log, venvPython } from "./util.mjs";
 
 const PKG = "rainbow-rb-sdk";
 
-async function fetchPypi() {
+async function fetchVersions() {
   try {
     const res = await fetch(`https://pypi.org/pypi/${PKG}/json`);
-    return res.ok ? await res.json() : null;
+    if (!res.ok) return [];
+    const data = await res.json();
+    return Object.keys(data.releases || {}).sort((a, b) =>
+      b.localeCompare(a, undefined, { numeric: true }),
+    );
   } catch {
-    return null;
+    return [];
   }
 }
 
-async function fetchVersions() {
-  const data = await fetchPypi();
-  return Object.keys(data?.releases || {}).sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
-}
-
 export async function runSdk(args = []) {
   const sub = args[0];
   const root = findPluginRoot();
@@ -42,25 +42,23 @@ export async function runSdk(args = []) {
   if (sub === "update") {
     let version = args[1];
     if (!version) {
-      // info.version = latest stable
-      version = (await fetchPypi())?.info?.version;
-      if (!version) throw new Error("could not fetch the latest version (offline?). Pass one: muscat-pk sdk update <version>");
+      const versions = await fetchVersions();
+      version = versions[0] || "latest";
     }
-    // rainbow-rb-* pin each other exactly — bump them together.
     let content = existsSync(reqs) ? readFileSync(reqs, "utf8") : "";
-    const pinned = /^(rainbow-rb-[\w-]+)\s*==.*$/gim;
-    const bumped = [...content.matchAll(pinned)].map((m) => m[1]);
-    content = content.replace(pinned, (_m, name) => `${name}==${version}`);
-    if (!bumped.some((n) => n.toLowerCase() === PKG)) {
-      content = (content ? content.trimEnd() + "\n" : "") + `${PKG}==${version}\n`;
-      bumped.push(PKG);
+    const line = `${PKG}==${version}`;
+    if (new RegExp(`^${PKG}==`, "m").test(content)) {
+      content = content.replace(new RegExp(`^${PKG}==.*$`, "m"), line);
+    } else {
+      content = (content ? content.trimEnd() + "\n" : "") + line + "\n";
     }
     writeFileSync(reqs, content);
-    log.ok(`requirements.txt → ${bumped.map((n) => `${n}==${version}`).join(", ")}`);
+    log.ok(`requirements.txt → ${line}`);
 
-    if (existsSync(venvPython(resolve(root, ".venv")))) {
-      log.step("refreshing .venv (for your editor)…");
-      if (!ensureIdeVenv(root)) log.warn(".venv refresh failed — the Docker dev container is unaffected.");
+    const py = venvPython(resolve(root, ".venv"));
+    if (existsSync(py)) {
+      log.step("pip install -r requirements.txt (.venv, for your editor)…");
+      spawnSync(py, ["-m", "pip", "install", "-q", "-r", reqs], { cwd: root, stdio: "inherit" });
     } else {
       log.info("Installed automatically on the next `muscat-pk dev` / `dev:back` (Docker container).");
     }