@rainbow-robotics/muscat-plugin-kit 0.1.2-dev.9 → 1.0.1

package/cli/src/cpp.mjs

@@ -0,0 +1,61 @@
+// Shared C++ Docker helpers (Ubuntu 24.04 + build-essential + cmake).
+// Matches the robot OS so the compiled binary is relocatable to the robot.
+// Used by dev:back (interactive dev loop) and build (export the binary into the ZIP).
+import { spawnSync } from "node:child_process";
+import { dirname } from "node:path";
+import { hasBin, log, pruneMuskatImages, resolveDockerfile } from "./util.mjs";
+
+export const CPP_DEV_IMAGE = "muscat-pk-cpp-dev";
+
+export function assertDockerReady() {
+  if (!hasBin("docker")) {
+    throw new Error("Docker not found. C++ builds need Docker (Ubuntu 24.04 + cmake container).");
+  }
+}
+
+/** Build the dev image from the kit's bundled Dockerfile (Docker layer-caches). */
+export async function ensureImage(image = CPP_DEV_IMAGE, { platform = null } = {}) {
+  const dockerfile = await resolveDockerfile("Dockerfile.cpp");
+  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();
+}
+
+// Docker platform token for each target arch
+export const ARCH_DOCKER_PLATFORM = {
+  amd64: "linux/amd64",
+  arm64: "linux/arm64",
+};
+
+/**
+ * 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", arch = null } = {}) {
+  const buildDir = arch ? `cpp/build-${arch}` : "cpp/build";
+  const dockerPlatform = arch ? ARCH_DOCKER_PLATFORM[arch] : null;
+  const platformFlags = dockerPlatform ? ["--platform", dockerPlatform] : [];
+  // arch 빌드 시 arch별 이미지 사용 (로컬 이미지와 platform 불일치 방지)
+  const actualImage = arch ? `${CPP_DEV_IMAGE}-${arch}` : image;
+  const script = [
+    `cmake -S cpp -B ${buildDir} -DCMAKE_BUILD_TYPE=${buildType}`,
+    `cmake --build ${buildDir} -j`,
+  ].join(" && ");
+  const label = arch ? `cmake build (${buildType}, ${arch}, in container)…` : `cmake build (${buildType}, in container)…`;
+  log.step(label);
+  const r = spawnSync(
+    "docker",
+    ["run", "--rm", ...platformFlags, "-v", `${root}:/plugin`, "-w", "/plugin", actualImage, "bash", "-lc", script],
+    { cwd: root, stdio: "inherit" },
+  );
+  if (r.status !== 0) throw new Error(`cmake build failed${arch ? ` (${arch})` : ""}.`);
+}

package/cli/src/dev.mjs

@@ -1,10 +1,162 @@
-// muscat-pk dev — run dev:ui and dev:back together.
+// muscat-pk dev — run the Socket.IO bridge (Docker), dev:ui, and dev:back together.
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { connect as netConnect } from "node:net";
+import { release } from "node:os";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { runDevUi } from "./devUi.mjs";
-import { runDevBack } from "./devBack.mjs";
-import { log } from "./util.mjs";
+import { runDevBack, stopDevBackContainers } from "./devBack.mjs";
+import { startBridge, stopBridge, BRIDGE_CONTAINER, BRIDGE_PORT } from "./bridge.mjs";
+import { assertManifestPorts } from "./manifest.mjs";
+import { formatPortRanges } from "./ports.mjs";
+import {
+  ensureDocker,
+  ensureIdeVenv,
+  findPluginRoot,
+  log,
+  prompt,
+  promptRobotConnection,
+  venvPython,
+} from "./util.mjs";
+import { ensureRemoteZenohEnv, isRemoteRobot } from "./zenohDev.mjs";
+
+const HOST_AGENT_PATH = fileURLToPath(new URL("./host_agent.py", import.meta.url));
+const isWsl = () => process.platform === "linux" && /microsoft|wsl/i.test(release());
+const canAutoStartHostAgent = () => process.platform === "darwin" || isWsl();
+
+function waitForHostAgent(port, { timeoutMs = 30_000 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  return new Promise((resolve, reject) => {
+    const probe = () => {
+      const sock = netConnect(port, "127.0.0.1");
+      sock.once("connect", () => { sock.destroy(); resolve(true); });
+      sock.once("error", () => {
+        sock.destroy();
+        if (Date.now() >= deadline) {
+          reject(new Error(`host SDK agent did not open port ${port} in time`));
+          return;
+        }
+        setTimeout(probe, 300);
+      });
+    };
+    probe();
+  });
+}
+
+const DEFAULT_PROXY_PORT = 47100;
+
+// Start the host-side Zenoh byte-proxy (host_agent.py) for a remote robot —
+// see host_agent.py for why a Docker Desktop container can't join the
+// robot's Zenoh mesh itself. Sets MUSCAT_PROXY_ENDPOINT for dev:back.
+// Returns the child process, or null if not applicable / disabled.
+async function maybeStartHostAgent(root, { robotIp, robotToken }) {
+  if (process.env.MUSCAT_PROXY_ENDPOINT) {
+    log.step(`Zenoh via host byte-proxy → ${process.env.MUSCAT_PROXY_ENDPOINT}`);
+    return null;
+  }
+  if (process.env.MUSCAT_HOST_AGENT_DISABLE === "1") return null;
+  if (!canAutoStartHostAgent() || !isRemoteRobot(robotIp)) return null;
+
+  const agentPath = process.env.MUSCAT_HOST_AGENT_SCRIPT || HOST_AGENT_PATH;
+  if (!existsSync(agentPath)) return null;
+
+  if (!ensureIdeVenv(root)) {
+    log.warn("host Zenoh byte-proxy skipped: could not prepare .venv");
+    return null;
+  }
+
+  // advertiseHost/zenohPort = the host_agent's OWN robot-facing Zenoh session
+  // (host LAN IP + port the robot reverse-dials into). The container never
+  // sees or needs these — it only talks to the proxyPort below.
+  const zenoh = await ensureRemoteZenohEnv(robotIp, { log });
+  const advertiseHost = zenoh?.advertiseHost || process.env.MUSCAT_ZENOH_ADVERTISE_HOST;
+  const zenohPort = zenoh?.zenohPort || Number(process.env.MUSCAT_ZENOH_PORT);
+  if (!advertiseHost || !zenohPort) {
+    log.warn("host Zenoh byte-proxy skipped: could not determine host LAN IP / port");
+    return null;
+  }
+  const proxyPort = Number(process.env.MUSCAT_PROXY_PORT) || DEFAULT_PROXY_PORT;
+
+  log.step("starting host Zenoh byte-proxy (Docker Desktop query-routing workaround)...");
+  const py = venvPython(resolve(root, ".venv"));
+  const child = spawn(py, [agentPath], {
+    cwd: root,
+    stdio: ["ignore", "inherit", "inherit"],
+    env: {
+      ...process.env,
+      MUSCAT_ROBOT_HOST: robotIp,
+      MUSCAT_ROBOT_TOKEN: robotToken,
+      MUSCAT_ZENOH_ADVERTISE_HOST: advertiseHost,
+      MUSCAT_ZENOH_PORT: String(zenohPort),
+      MUSCAT_PROXY_PORT: String(proxyPort),
+    },
+  });
+
+  try {
+    await waitForHostAgent(proxyPort);
+  } catch (e) {
+    child.kill();
+    throw e;
+  }
+
+  // advertiseHost (not host.docker.internal): a Docker Desktop container run
+  // under `dev` may share the bridge container's netns (--network container:),
+  // which has no host-gateway alias configured — the host's real LAN IP
+  // always resolves regardless of netns mode.
+  const proxyEndpoint = `${advertiseHost}:${proxyPort}`;
+  process.env.MUSCAT_PROXY_ENDPOINT = proxyEndpoint;
+  process.env.MUSCAT_PROXY_PORT = String(proxyPort);
+  log.step(`Zenoh via host byte-proxy → ${proxyEndpoint}`);
+  return child;
+}
 
 export async function runDev(args = []) {
-  log.step("starting dev:ui + dev:back");
+  const root = findPluginRoot();
+  const portRanges = assertManifestPorts(root);
+  if (portRanges.length > 0) {
+    log.step(`plugin backend ports declared: ${formatPortRanges(portRanges)}`);
+    process.env.MUSCAT_PK_PORTS_PRECHECKED = "1";
+  }
+  ensureDocker();
+  const { robotIp, robotToken } = await promptRobotConnection(args);
+  process.env.MUSCAT_ROBOT_HOST  = robotIp;
+  if (robotToken) process.env.MUSCAT_ROBOT_TOKEN = robotToken;
+
+  const remoteRobot = isRemoteRobot(robotIp);
+  const hostAgent = await maybeStartHostAgent(root, { robotIp, robotToken });
+  const proxyEndpoint = process.env.MUSCAT_PROXY_ENDPOINT || "";
+  // No proxy (Linux, disabled, ...): fall back to the container reverse-dialing
+  // the robot itself — startBridge() then publishes the zenoh port for it.
+  if (!proxyEndpoint) await ensureRemoteZenohEnv(robotIp, { log });
+
+  log.step("starting Socket.IO bridge (Docker) + dev:ui + dev:back");
+  const bridgeStarted = await startBridge({
+    zenohPort: remoteRobot && !proxyEndpoint ? Number(process.env.MUSCAT_ZENOH_PORT) : null,
+  });
+
+  if (!bridgeStarted) {
+    log.warn(`port ${BRIDGE_PORT} is already in use — can't start Socket.IO bridge.`);
+    const answer = await prompt("  Proceed without Socket.IO bridge? [y/N]: ");
+    if (answer.toLowerCase() !== "y") return;
+    log.info("proceeding without bridge — backend will skip network sharing.");
+  } else {
+    // Tell dev:back which bridge container to share a netns with, so the backend
+    // reaches the bridge at localhost:10000 (no host.docker.internal).
+    process.env.MUSCAT_PK_BRIDGE_CONTAINER = BRIDGE_CONTAINER;
+  }
+
+  process.env.MUSCAT_PK_MANAGED_DEV = "1";
+
+  const cleanup = () => {
+    if (hostAgent && hostAgent.exitCode === null) hostAgent.kill();
+    stopDevBackContainers();
+    if (bridgeStarted) stopBridge();
+  };
+  process.once("SIGINT", cleanup);
+  process.once("SIGTERM", cleanup);
+  process.once("exit", cleanup);
+
   // dev:back runs to completion / detaches on its own; dev:ui owns the process.
   runDevBack().catch((e) => log.warn(`dev:back: ${e.message}`));
   await runDevUi(args);