@rainbow-robotics/muscat-plugin-kit 0.1.2-dev.4 → 0.1.2-dev.40

package/cli/src/ros2.mjs

@@ -0,0 +1,90 @@
+// Shared ROS2 Docker helpers (Jazzy + Python 3.12 — matches the robot backend).
+// Used by dev:back (interactive dev loop) and build (export install/ into the ZIP).
+import { spawnSync } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { hasBin, log, pruneMuskatImages, resolveDockerfile } from "./util.mjs";
+
+export const ROS2_DEV_IMAGE = "muscat-pk-ros2-dev";
+
+/** First package directory under ros2_ws/src (the colcon package name). */
+export function ros2PackageName(root) {
+  const srcDir = resolve(root, "ros2_ws/src");
+  if (!existsSync(srcDir)) return null;
+  const dirs = readdirSync(srcDir, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name);
+  return dirs[0] ?? null;
+}
+
+export function assertDockerReady() {
+  if (!hasBin("docker")) {
+    throw new Error("Docker not found. ROS2 needs Docker (Jazzy + Python 3.12 container).");
+  }
+}
+
+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 async function ensureImage(image = ROS2_DEV_IMAGE, { platform = null } = {}) {
+  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 r = spawnSync(
+    "docker",
+    ["build", ...platformFlags, "-t", image, "-f", dockerfile, dirname(dockerfile)],
+    { stdio: "inherit" },
+  );
+  if (r.status !== 0) throw new Error("docker build failed.");
+  pruneMuskatImages();
+}
+
+/**
+ * Run `colcon build` inside the container, producing ros2_ws/install on the host
+ * (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).
+ */
+/**
+ * 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 = [
+    "pip install -r requirements.txt --break-system-packages --ignore-installed -q || true",
+    "cd ros2_ws",
+    // 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}/…`
+    : `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", ...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/socketBridge.mjs

@@ -0,0 +1,129 @@
+import { createServer } from "node:http";
+import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { Server } from "socket.io";
+
+// Self-contained logger — this module also runs standalone inside the bridge
+// Docker container, where ./util.mjs is not available.
+const log = {
+  step: (...m) => console.log("›", ...m),
+  warn: (...m) => console.warn("⚠", ...m),
+};
+
+const DEFAULT_ACTION_TIMEOUT_MS = 10_000;
+
+export function startSocketBridge({ port = 10000, host = "0.0.0.0" } = {}) {
+  const httpServer = createServer();
+  const io = new Server(httpServer, { cors: { origin: "*" } });
+
+  // topic → socketId (serve_register로 등록된 queryable)
+  const queryables = new Map();
+  // call_id → { timer, resolve } (action → serve_call → serve_reply 대기)
+  const pending = new Map();
+
+  function cleanupSocket(socket) {
+    for (const [topic, sid] of queryables) {
+      if (sid === socket.id) queryables.delete(topic);
+    }
+    for (const [id, p] of pending) {
+      if (p.sid !== socket.id) continue;
+      clearTimeout(p.timer);
+      p.resolve(undefined);
+      pending.delete(id);
+    }
+  }
+
+  io.on("connection", (socket) => {
+    socket.on("sub", async (data = {}) => {
+      if (!data.topic) return;
+      await socket.join(`t:${data.topic}`);
+    });
+
+    socket.on("unsub", async (data = {}) => {
+      if (!data.topic) return;
+      await socket.leave(`t:${data.topic}`);
+    });
+
+    socket.on("pub", (data = {}) => {
+      const { topic, payload } = data;
+      if (!topic) return;
+      io.to(`t:${topic}`).emit("msg", { topic, payload });
+    });
+
+    socket.on("serve_register", (data = {}) => {
+      if (!data.topic) return;
+      queryables.set(data.topic, socket.id);
+    });
+
+    socket.on("serve_unregister", (data = {}) => {
+      if (queryables.get(data.topic) === socket.id) queryables.delete(data.topic);
+    });
+
+    socket.on("serve_reply", (data = {}) => {
+      const p = pending.get(data.id);
+      if (!p) return;
+      clearTimeout(p.timer);
+      p.resolve(data.payload);
+      pending.delete(data.id);
+    });
+
+    socket.on("action", (data = {}, ack) => {
+      const { topic, payload } = data;
+      const targetSid = queryables.get(topic);
+      const target = targetSid && io.sockets.sockets.get(targetSid);
+      if (!target) {
+        if (typeof ack === "function") ack(undefined);
+        return;
+      }
+      const id = randomUUID();
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        if (typeof ack === "function") ack(undefined);
+      }, DEFAULT_ACTION_TIMEOUT_MS);
+      pending.set(id, {
+        sid: targetSid,
+        timer,
+        resolve: (v) => { if (typeof ack === "function") ack(v); },
+      });
+      target.emit("serve_call", { id, topic, payload });
+    });
+
+    socket.on("disconnect", () => cleanupSocket(socket));
+  });
+
+  return new Promise((resolve) => {
+    httpServer.once("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        log.warn(`Socket.IO bridge already running on :${port} — skipping`);
+        io.close();
+        httpServer.close();
+        resolve({ close: () => {} });
+      } else {
+        throw err;
+      }
+    });
+
+    httpServer.listen(port, host, () => {
+      log.step(`Socket.IO bridge listening on ws://127.0.0.1:${port}`);
+
+      const close = () => {
+        for (const p of pending.values()) {
+          clearTimeout(p.timer);
+          p.resolve(undefined);
+        }
+        pending.clear();
+        queryables.clear();
+        io.close();
+        httpServer.close();
+      };
+
+      resolve({ close });
+    });
+  });
+}
+
+// When executed directly (inside the bridge Docker container), start the server.
+if (process.argv[1] && process.argv[1] === fileURLToPath(import.meta.url)) {
+  const port = Number(process.env.PORT) || 10000;
+  startSocketBridge({ port });
+}

package/cli/src/type.mjs

@@ -0,0 +1,105 @@
+// muscat-pk type change — switch an existing plugin's backend type.
+//   python | cpp | ros2 (rclpy) | ros2-cpp (rclcpp).
+//   Adds the matching backend overlay; never deletes existing user code
+//   (e.g. ros2_ws/ or cpp/ are left in place when switching away).
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { findPluginRoot, log, prompt } from "./util.mjs";
+import {
+  TYPE_CHOICES,
+  applyTokens,
+  deriveNames,
+  overlayCpp,
+  overlayRos2,
+  runtimeForChoice,
+} from "./new.mjs";
+
+const TYPES = Object.keys(TYPE_CHOICES);
+
+function readManifest(root) {
+  const path = resolve(root, "manifest.json");
+  if (!existsSync(path)) throw new Error(`manifest.json not found in ${root}`);
+  return { path, json: JSON.parse(readFileSync(path, "utf8")) };
+}
+
+// Derive the current `--type`-style key from a manifest runtime block.
+function currentTypeKey(runtime) {
+  if (runtime?.type === "ros2") return runtime.rosClient === "rclcpp" ? "ros2-cpp" : "ros2";
+  return runtime?.type ?? "python";
+}
+
+export async function runType(args) {
+  // accept `type change`, `type`, `type --to ros2-cpp`
+  const sub = args[0];
+  const toFlagIdx = args.indexOf("--to");
+  let to = toFlagIdx >= 0 ? args[toFlagIdx + 1] : undefined;
+
+  const root = findPluginRoot();
+  const { path, json } = readManifest(root);
+  const current = currentTypeKey(json.runtime);
+
+  if (sub && sub !== "change") {
+    log.warn(`unknown subcommand '${sub}'. Usage: muscat-pk type change [--to python|cpp|ros2|ros2-cpp]`);
+  }
+
+  if (!to) {
+    console.log(`\n현재 타입: ${current}`);
+    console.log("변경할 타입을 선택하세요:");
+    console.log("  1) Python");
+    console.log("  2) C++");
+    console.log("  3) ROS2 (rclpy / Python)");
+    console.log("  4) ROS2 (rclcpp / C++)");
+    const choice = await prompt("\n선택 [1/2/3/4]: ", "");
+    to = { "1": "python", "2": "cpp", "3": "ros2", "4": "ros2-cpp" }[choice];
+  }
+
+  if (!TYPES.includes(to)) {
+    throw new Error(`invalid type. choose python | cpp | ros2 | ros2-cpp.`);
+  }
+  if (to === current) {
+    log.info(`already '${current}' — nothing to change.`);
+    return;
+  }
+
+  const runtimeChoice = TYPE_CHOICES[to];
+  const { slug, pluginName, pluginClass, pluginId } = deriveNames(root);
+
+  if (runtimeChoice.type === "ros2") {
+    if (existsSync(resolve(root, "ros2_ws"))) {
+      log.warn("ros2_ws/ already exists — keeping it, only flipping manifest type.");
+    } else {
+      log.step(`adding ros2_ws/ overlay (${runtimeChoice.rosClient})`);
+      await overlayRos2(root, slug, runtimeChoice.rosClient);
+      applyTokens(root, {
+        __PLUGIN_ID__: pluginId,
+        __PLUGIN_NAME__: pluginName,
+        __PLUGIN_SLUG__: slug,
+        __PLUGIN_CLASS__: pluginClass,
+        __RUNTIME_TYPE__: "ros2",
+      });
+    }
+  } else if (runtimeChoice.type === "cpp") {
+    if (existsSync(resolve(root, "cpp"))) {
+      log.warn("cpp/ already exists — keeping it, only flipping manifest type.");
+    } else {
+      log.step("adding cpp/ overlay");
+      await overlayCpp(root);
+      applyTokens(root, {
+        __PLUGIN_ID__: pluginId,
+        __PLUGIN_NAME__: pluginName,
+        __PLUGIN_SLUG__: slug,
+        __PLUGIN_CLASS__: pluginClass,
+        __RUNTIME_TYPE__: "cpp",
+      });
+    }
+  } else {
+    // → python. Leave any ros2_ws/ or cpp/ in place (never delete user code).
+    if (existsSync(resolve(root, "ros2_ws")) || existsSync(resolve(root, "cpp"))) {
+      log.warn("existing backend dir left in place (not deleted). Remove it manually if unused.");
+    }
+  }
+
+  json.runtime = runtimeForChoice(runtimeChoice, slug);
+  writeFileSync(path, JSON.stringify(json, null, 2) + "\n");
+  log.ok(`${basename(root)} type: ${current} → ${to}`);
+}

package/cli/src/uninstall.mjs

@@ -0,0 +1,98 @@
+// muscat-pk uninstall - remove the installed CLI, whether npm-global or S3 binary.
+import { execSync, spawn, spawnSync } from "node:child_process";
+import { existsSync, realpathSync, rmSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { KIT_PUBLISHED_NAME, kitRoot, log, parseArgs } from "./util.mjs";
+
+const isBinaryMode = typeof Bun !== "undefined";
+
+function isInside(child, parent) {
+  const rel = relative(parent, child);
+  return rel === "" || (!!rel && !rel.startsWith("..") && !rel.includes(":"));
+}
+
+function npmGlobalRoot() {
+  return execSync("npm root -g", { encoding: "utf8" }).trim();
+}
+
+function isNpmGlobalInstall() {
+  try {
+    return isInside(realpathSync(kitRoot), realpathSync(npmGlobalRoot()));
+  } catch {
+    return false;
+  }
+}
+
+function uninstallNpmGlobal() {
+  log.step(`npm uninstall -g ${KIT_PUBLISHED_NAME}`);
+  execSync(`npm uninstall -g ${KIT_PUBLISHED_NAME}`, { stdio: "inherit" });
+  log.ok("Global npm package removed.");
+}
+
+function uninstallBinary() {
+  const execPath = process.execPath;
+  log.step(`Removing binary: ${execPath}`);
+
+  if (process.platform === "win32") {
+    const ps = `Start-Sleep -Milliseconds 500; Remove-Item -Force '${execPath}'`;
+    spawn("powershell", ["-NoProfile", "-Command", ps], {
+      detached: true,
+      stdio: "ignore",
+    }).unref();
+    log.ok("Binary will be removed after this process exits.");
+    return;
+  }
+
+  try {
+    rmSync(execPath, { force: true });
+  } catch (err) {
+    if (err?.code !== "EACCES" && err?.code !== "EPERM") throw err;
+    log.info("  sudo is required...");
+    const result = spawnSync("sudo", ["rm", "-f", execPath], { stdio: "inherit" });
+    if (result.status !== 0) throw new Error(`sudo rm failed: ${execPath}`);
+  }
+
+  const parent = dirname(execPath);
+  for (const shim of ["muscat-pk.cmd", "muscat-pk.ps1"]) {
+    rmSync(join(parent, shim), { force: true });
+  }
+
+  log.ok("Binary removed.");
+}
+
+export async function runUninstall(args = []) {
+  const opts = parseArgs(args, { booleans: ["help"] });
+
+  if (opts.help) {
+    log.info(
+      [
+        "Usage: muscat-pk uninstall",
+        "",
+        "Removes the installed muscat-pk CLI.",
+        "  npm global install  -> npm uninstall -g @rainbow-robotics/muscat-plugin-kit",
+        "  S3 binary install   -> remove the muscat-pk executable",
+      ].join("\n"),
+    );
+    return;
+  }
+
+  if (isBinaryMode) {
+    uninstallBinary();
+    return;
+  }
+
+  if (isNpmGlobalInstall()) {
+    uninstallNpmGlobal();
+    return;
+  }
+
+  const localBin = process.argv[1] || "";
+  if (localBin.includes(`${join("node_modules", ".bin")}`) || existsSync(join(process.cwd(), "package.json"))) {
+    log.warn("This muscat-pk appears to be running from a project/local install.");
+    log.warn("Remove it from the project package manager instead, for example:");
+    log.warn(`  npm uninstall ${KIT_PUBLISHED_NAME}`);
+    return;
+  }
+
+  throw new Error("Could not determine install mode. Remove muscat-pk manually from your PATH.");
+}