@rainbow-robotics/muscat-plugin-kit 0.1.2-dev.8 → 0.10.1-dev.0

package/cli/src/sim.mjs

@@ -0,0 +1,177 @@
+// `dev --sim <model>`: robot simulators next to the local Muscat, for developing without a robot.
+// Cobot: coreSW (rainbowroboticsofficial/cobot-sim) per component, joined to common's Zenoh.
+// RB-Y1: rby1-sim + Xvfb built locally (it needs a GLFW window; there is no headless mode yet).
+import { spawnSync } from "node:child_process";
+import { canSkipImageBuild, log } from "./util.mjs";
+import { MUSCAT_NETWORK } from "./muscatLocal.mjs";
+
+const COBOT_IMAGE = "rainbowroboticsofficial/cobot-sim";
+const RBY1_IMAGE = "rainbowroboticsofficial/rby1-sim";
+const RBY1_LOCAL = "muscat-pk-rby1-sim";
+const RBY1_CONTAINER = "muscat-pk-sim-rby1";
+const SIM_LABEL = "com.rainbow-robotics.muscat-pk.sim";
+
+// ponytail: model table in code; move to S3 version.json when sims are versioned with Muscat (amr: no sim yet)
+// sim name → coreSW RB_MODEL per component, and the Muscat robot model it registers as.
+const COBOT_MODELS = {
+  "500920": { robotModel: "C500920", models: ["500920"] },
+  RBY2: { robotModel: "RBY2", models: ["C500880", "C501880", "C502880"] },
+};
+const RBY1_TYPES = ["a", "m", "ub"];
+
+// rby1-sim renders MuJoCo with software GL every frame; one GL thread and a tiny screen cut it from
+// ~3.5 cores to ~1. The cap keeps a busy Mac usable; the image already skips RT-loop timeouts.
+const RBY1_DOCKERFILE = `ARG BASE=0.10.6-m_v1.3
+FROM ${RBY1_IMAGE}:\${BASE}
+RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends xvfb && rm -rf /var/lib/apt/lists/*
+ENV LP_NUM_THREADS=0 DISPLAY=:99
+CMD ["sh", "-c", "Xvfb :99 -screen 0 320x240x16 -nolisten tcp & sleep 1; exec ./app_main"]
+`;
+
+export const SIM_NAMES = [...Object.keys(COBOT_MODELS), ...RBY1_TYPES.map((t) => `rby1-${t}`)];
+
+/** `muscat-pk sim list`: "<name>\t<what runs>" per line, for scripts and the VS Code Dev picker. */
+export function runSimList() {
+  for (const [name, { robotModel, models }] of Object.entries(COBOT_MODELS))
+    console.log(`${name}\tcobot · ${robotModel}${models.length > 1 ? ` (${models.join(", ")})` : ""}`);
+  for (const t of RBY1_TYPES) console.log(`rby1-${t}\tRB-Y1 ${t.toUpperCase()}`);
+}
+
+/** "500920" | "RBY2" | "rby1-m" | "rby1-m_v1.2" → { services, env, ... } or null. */
+export function parseSim(name) {
+  if (COBOT_MODELS[name]) return { name, kind: "cobot", services: ["log", "manipulate"], env: {}, ...COBOT_MODELS[name] };
+  const m = /^rby1-(a|m|ub)(?:_(v[\d.]+))?$/.exec(name ?? "");
+  if (m) return { name, kind: "rby1", services: ["log", "rby1"], env: { RBY1_HOST: RBY1_CONTAINER }, robotModel: m[1], type: m[1], version: m[2] };
+  return null;
+}
+
+/** Only an explicit --sim <name> runs a simulator. */
+export function resolveSim(simArg, manifest) {
+  if (simArg === undefined) return null;
+  const sim = typeof simArg === "string" ? parseSim(simArg) : null;
+  if (!sim) throw new Error(`--sim takes one of: ${SIM_NAMES.join(", ")} (rby1 also takes rby1-m_v1.2)`);
+  const models = Array.isArray(manifest.targetModels) ? manifest.targetModels : null;
+  if (models && !models.includes(simArg)) log.warn(`--sim ${simArg} is not in manifest targetModels (${models.join(", ")})`);
+  return sim;
+}
+
+async function hubTags(repo) {
+  const res = await fetch(`https://hub.docker.com/v2/repositories/${repo}/tags?page_size=100&ordering=last_updated`, {
+    signal: AbortSignal.timeout(10_000),
+  });
+  if (!res.ok) throw new Error(`Docker Hub ${repo}: HTTP ${res.status}`);
+  return (await res.json()).results.map((t) => t.name);
+}
+
+// "0.10.6-m_v1.3" → [0, 10, 6, 1, 3]
+const semver = (v) => v.split(/[._v-]/).map(Number).filter((n) => !Number.isNaN(n));
+const newer = (a, b) => {
+  const [x, y] = [semver(a), semver(b)];
+  for (let i = 0; i < Math.max(x.length, y.length); i++) if ((x[i] ?? 0) !== (y[i] ?? 0)) return (x[i] ?? 0) - (y[i] ?? 0);
+  return 0;
+};
+
+// Latest published tag; offline falls back to whatever was pulled before.
+async function latestTag(repo, pattern) {
+  try {
+    const tags = (await hubTags(repo)).filter((t) => pattern.test(t));
+    if (tags.length) return tags.sort(newer).at(-1);
+  } catch (e) {
+    log.warn(`${e.message} — using a local image`);
+  }
+  const tags = localTags(repo).filter((t) => pattern.test(t));
+  if (!tags.length) throw new Error(`no ${repo} image matching ${pattern} (offline and nothing pulled yet)`);
+  return tags.sort(newer).at(-1);
+}
+
+function localTags(repo) {
+  const out = spawnSync("docker", ["images", repo, "--format", "{{.Tag}}"], { encoding: "utf8" }).stdout ?? "";
+  return out.split("\n").map((t) => t.trim()).filter(Boolean);
+}
+
+// A new sim release replaces the previous one (100–700MB each); other model types' tags stay.
+function removeOldTags(repo, pattern, keep) {
+  for (const tag of localTags(repo).filter((t) => t !== keep && pattern.test(t)))
+    spawnSync("docker", ["rmi", `${repo}:${tag}`], { stdio: "ignore" });
+}
+
+function pull(image) {
+  if (spawnSync("docker", ["image", "inspect", image], { stdio: "ignore" }).status === 0) return;
+  log.step(`docker pull ${image}…`);
+  if (spawnSync("docker", ["pull", image], { stdio: "inherit" }).status !== 0) throw new Error(`docker pull ${image} failed`);
+}
+
+function run(name, args) {
+  spawnSync("docker", ["rm", "-f", name], { stdio: "ignore" });
+  const r = spawnSync("docker", [
+    // --ipc host like the robot: the cobot coreSWs share one shm segment (RB_MESSAGE_SHM, a slot per model).
+    "run", "-d", "--name", name, "--network", MUSCAT_NETWORK, "--ipc", "host",
+    "--label", "com.rainbow-robotics.muscat-pk=true", "--label", `${SIM_LABEL}=true`,
+    ...args,
+  ], { stdio: ["ignore", "ignore", "inherit"] });
+  if (r.status !== 0) throw new Error(`failed to start ${name}`);
+}
+
+// The Muscat UI (robot info, components, connection state) follows the registered robot model.
+async function registerRobot(robotModel) {
+  const res = await fetch("http://127.0.0.1:3000/common/upsert-robot-info", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ robotModel }),
+  });
+  if (!res.ok) throw new Error(`upsert-robot-info ${robotModel}: HTTP ${res.status}`);
+  log.step(`robot model ${robotModel} registered in the local Muscat`);
+}
+
+/** Start the simulator containers and register the robot model; returns the container names. */
+export async function startSim(sim) {
+  const names = await startContainers(sim);
+  await registerRobot(sim.robotModel);
+  return names;
+}
+
+// Needs the local Muscat on MUSCAT_NETWORK.
+async function startContainers(sim) {
+  stopSims();
+  if (sim.kind === "cobot") {
+    const pattern = /^\d+\.\d+\.\d+$/;
+    const tag = await latestTag(COBOT_IMAGE, pattern);
+    const image = `${COBOT_IMAGE}:${tag}`;
+    pull(image);
+    removeOldTags(COBOT_IMAGE, pattern, tag);
+    const names = sim.models.map((model) => `muscat-pk-sim-${model}`);
+    sim.models.forEach((model, i) => run(names[i], [
+      "--cap-add", "SYS_NICE", "--ulimit", "rtprio=99",
+      "-e", `RB_MODEL=${model}`,
+      "-e", "RB_ZENOH_CONNECT=tcp/muscat-pk-muscat:7447",
+      image,
+    ]));
+    log.step(`cobot sim ${sim.name} (${image}) → ${sim.models.join(", ")}`);
+    return names;
+  }
+
+  const pattern = sim.version ? new RegExp(`^\\d+\\.\\d+\\.\\d+-${sim.type}_${sim.version.replace(/\./g, "\\.")}$`) : new RegExp(`^\\d+\\.\\d+\\.\\d+-${sim.type}_v[\\d.]+$`);
+  const base = await latestTag(RBY1_IMAGE, pattern);
+  const image = `${RBY1_LOCAL}:${base}`;
+  if (!canSkipImageBuild(image)) {
+    log.step(`building ${image} (rby1-sim + Xvfb, first run pulls ~150MB)…`);
+    const r = spawnSync("docker", ["build", "-t", image, "--build-arg", `BASE=${base}`, "--label", "com.rainbow-robotics.muscat-pk=true", "-"], {
+      input: RBY1_DOCKERFILE,
+      stdio: ["pipe", "inherit", "inherit"],
+    });
+    if (r.status !== 0) throw new Error(`docker build ${image} failed`);
+  }
+  removeOldTags(RBY1_LOCAL, pattern, base);
+  removeOldTags(RBY1_IMAGE, pattern, base);
+  run(RBY1_CONTAINER, ["--cpus", process.env.MUSCAT_PK_RBY1_CPUS || "1.5", image]);
+  log.step(`rby1 sim ${base} → ${RBY1_CONTAINER}:50051`);
+  return [RBY1_CONTAINER];
+}
+
+export function stopSims() {
+  const ids = (spawnSync("docker", ["ps", "-aq", "--filter", `label=${SIM_LABEL}=true`], { encoding: "utf8" }).stdout ?? "").split("\n").filter(Boolean);
+  if (!ids.length) return;
+  // The cobot coreSWs share these under --ipc host; drop them so the next run starts from a fresh segment.
+  spawnSync("docker", ["exec", ids[0], "sh", "-c", "rm -f /dev/shm/RB_COBOT_SHM /dev/shm/RB_MESSAGE_SHM"], { stdio: "ignore" });
+  spawnSync("docker", ["rm", "-f", ...ids], { stdio: "ignore" });
+}

package/cli/src/storybook.mjs

@@ -0,0 +1,150 @@
+// muscat-pk storybook — serve the bundled Storybook (foundations + muscat) so
+// plugin authors can browse the real rb-components UI while developing.
+//
+// The static build is produced from apps/storybook (MUSCAT_STORYBOOK=true → only
+// the 1.foundations + 4.muscat sections, ordering-number prefixes stripped) and
+// staged into cli/storybook-dist so it ships inside the published muscat-pk.
+// In the monorepo it's built on demand if missing (or with --rebuild).
+import { createServer } from "node:http";
+import {
+  cpSync,
+  createReadStream,
+  existsSync,
+  mkdirSync,
+  rmSync,
+  statSync,
+} from "node:fs";
+import { execSync } from "node:child_process";
+import { copyFileSync } from "node:fs";
+import { extname, join, resolve } from "node:path";
+import { kitRoot, log, openBrowser, parseArgs } from "./util.mjs";
+
+// Shipped location (under cli/ → included in the npm "files" list).
+const SHIPPED_DIST = resolve(kitRoot, "cli/storybook-dist");
+// Raw .stories.tsx sources, staged alongside the compiled build — the `mcp`
+// command's get_component_example tool reads these directly (real usage
+// code, not just prop types) without needing a Storybook runtime.
+export const SHIPPED_STORIES_SRC = resolve(SHIPPED_DIST, "_stories-src");
+// Monorepo source (absent in an external install).
+const REPO_ROOT = resolve(kitRoot, "../..");
+const REPO_STORYBOOK = resolve(REPO_ROOT, "apps/storybook");
+const REPO_BUILD_OUT = resolve(REPO_STORYBOOK, "storybook-static-muscat");
+const REPO_MUSCAT_STORIES = resolve(REPO_STORYBOOK, "stories/4.muscat");
+const REPO_DESIGN_TOKENS = resolve(
+  REPO_ROOT,
+  "packages/rb-styles/css/output/rb-token.css",
+);
+// Generated Tailwind v4 token file (@theme colors + @utility typo-*), staged so
+// the `mcp` command's *_design_tokens tools work in an external install too.
+export const SHIPPED_DESIGN_TOKENS = resolve(SHIPPED_DIST, "_design-tokens.css");
+
+const CONTENT_TYPE = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".wasm": "application/wasm",
+};
+
+// Build apps/storybook (muscat subset) and stage it into cli/storybook-dist.
+// Monorepo only. Outside the monorepo (e.g. re-packing an already-published
+// copy) it's a no-op — the shipped cli/storybook-dist is already in place.
+export function buildStorybook() {
+  if (!existsSync(REPO_STORYBOOK)) {
+    log.info("apps/storybook not found — using the pre-staged storybook-dist.");
+    return;
+  }
+  log.step("building Storybook (foundations + muscat)…");
+  execSync("yarn workspace storybook storybook:build:muscat", {
+    cwd: REPO_ROOT,
+    stdio: "inherit",
+    env: { ...process.env, MUSCAT_STORYBOOK: "true" },
+  });
+  rmSync(SHIPPED_DIST, { recursive: true, force: true });
+  mkdirSync(SHIPPED_DIST, { recursive: true });
+  cpSync(REPO_BUILD_OUT, SHIPPED_DIST, { recursive: true });
+
+  // Stage raw .stories.tsx sources (not just the compiled JS bundle) for the
+  // `mcp` command's get_component_example tool.
+  if (existsSync(REPO_MUSCAT_STORIES)) {
+    cpSync(REPO_MUSCAT_STORIES, SHIPPED_STORIES_SRC, {
+      recursive: true,
+      filter: (src) => statSync(src).isDirectory() || src.endsWith(".stories.tsx"),
+    });
+  }
+
+  // Stage the design-token CSS for the `mcp` command's *_design_tokens tools.
+  if (existsSync(REPO_DESIGN_TOKENS)) {
+    copyFileSync(REPO_DESIGN_TOKENS, SHIPPED_DESIGN_TOKENS);
+  }
+
+  log.ok(`storybook → ${SHIPPED_DIST}`);
+}
+
+function serve(distDir, port) {
+  const server = createServer((req, res) => {
+    const url = decodeURIComponent((req.url || "/").split("?")[0]);
+    const rel = url === "/" ? "/index.html" : url;
+    const filePath = resolve(distDir, `.${rel}`);
+
+    // Serve the file if it's inside distDir and exists; otherwise fall back to
+    // index.html (Storybook is a single-page app).
+    if (
+      filePath.startsWith(distDir) &&
+      existsSync(filePath) &&
+      statSync(filePath).isFile()
+    ) {
+      const type = CONTENT_TYPE[extname(filePath)];
+      if (type) res.setHeader("Content-Type", type);
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      createReadStream(filePath).pipe(res);
+      return;
+    }
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    createReadStream(join(distDir, "index.html")).pipe(res);
+  });
+
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      log.error(`port ${port} is in use — pass a free one with --port <n>.`);
+      process.exit(1);
+    }
+    throw err;
+  });
+
+  server.listen(port, () => {
+    const url = `http://localhost:${port}`;
+    log.ok(`Storybook → ${url}`);
+    openBrowser(url);
+  });
+}
+
+export async function runStorybook(args = []) {
+  const { port = "6007", rebuild } = parseArgs(args, { booleans: ["rebuild"] });
+
+  const staged = existsSync(join(SHIPPED_DIST, "index.html"));
+  if (rebuild || !staged) {
+    if (existsSync(REPO_STORYBOOK)) {
+      buildStorybook();
+    } else if (!staged) {
+      throw new Error(
+        `Storybook build not found at ${SHIPPED_DIST}.\n` +
+          "  This build of muscat-pk was published without the bundled Storybook.",
+      );
+    }
+  }
+
+  serve(SHIPPED_DIST, Number(port));
+}