@rainbow-robotics/muscat-plugin-kit 1.10.1-dev.1 → 1.10.1

package/cli/src/cppIde.mjs

@@ -1,75 +1,75 @@
-// Editor (IntelliSense) support for C++ backends. The rb_sdk headers only exist inside the dev image,
-// so a host editor flags every SDK name. Copy them to .muscat-dev/sysroot and point
-// .vscode/c_cpp_properties.json at them, using the include dirs / defines rb_sdk's CMake target exports.
-// The build never reads these copies — it runs in the image.
-import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { cppSdkFiles, log } from "./util.mjs";
-
-const SYSROOT = ".muscat-dev/sysroot";
-const CONFIG_NAME = "Muscat";
-const COPY = ["/usr/include/rainbow", "/usr/include/eigen3", "/usr/lib/cmake/rb_sdk/rb_sdkTargets.cmake"];
-
-function imageId(image) {
-  const r = spawnSync("docker", ["image", "inspect", "-f", "{{.Id}}", image], { encoding: "utf8" });
-  return r.status === 0 ? r.stdout.trim() : null;
-}
-
-/** Copy the SDK headers out of `image` (once per image build) and write the VS Code C/C++ config. */
-export function syncCppIde(root, image) {
-  if (!cppSdkFiles(root).length) return;
-  const id = imageId(image);
-  if (!id) return;
-  const sysroot = resolve(root, SYSROOT);
-  const stamp = resolve(sysroot, ".image-id");
-  if (!existsSync(stamp) || readFileSync(stamp, "utf8") !== id) {
-    rmSync(sysroot, { recursive: true, force: true });
-    const create = spawnSync("docker", ["create", image], { encoding: "utf8" });
-    if (create.status !== 0) return log.warn("could not copy SDK headers for the editor (docker create failed).");
-    const container = create.stdout.trim();
-    try {
-      for (const src of COPY) {
-        const dest = resolve(sysroot, src.slice(1));
-        mkdirSync(resolve(dest, ".."), { recursive: true });
-        spawnSync("docker", ["cp", `${container}:${src}`, dest], { stdio: "ignore" });
-      }
-    } finally {
-      spawnSync("docker", ["rm", container], { stdio: "ignore" });
-    }
-    writeFileSync(stamp, id);
-    log.step(`SDK headers for the editor → ${SYSROOT}`);
-  }
-  writeCppProperties(root, readTarget(sysroot));
-}
-
-// INTERFACE_INCLUDE_DIRECTORIES / INTERFACE_COMPILE_DEFINITIONS of rb_sdk::rb_sdk, mapped into the sysroot.
-function readTarget(sysroot) {
-  const file = resolve(sysroot, "usr/lib/cmake/rb_sdk/rb_sdkTargets.cmake");
-  const text = existsSync(file) ? readFileSync(file, "utf8") : "";
-  const list = (key) => (text.match(new RegExp(`${key} "([^"]*)"`))?.[1] ?? "").split(";").filter(Boolean);
-  const prefix = `\${workspaceFolder}/${SYSROOT}/usr`;
-  const includes = list("INTERFACE_INCLUDE_DIRECTORIES").map((d) => d.replace("${_IMPORT_PREFIX}", prefix));
-  return {
-    includePath: [...(includes.length ? includes : [`${prefix}/include`]), `${prefix}/include/eigen3`],
-    defines: list("INTERFACE_COMPILE_DEFINITIONS"),
-  };
-}
-
-// Keeps other configurations; ours is replaced in place or put first so VS Code picks it by default.
-function writeCppProperties(root, { includePath, defines }) {
-  const file = resolve(root, ".vscode", "c_cpp_properties.json");
-  let props = { configurations: [], version: 4 };
-  if (existsSync(file)) {
-    try {
-      props = JSON.parse(readFileSync(file, "utf8"));
-    } catch {
-      return log.warn(".vscode/c_cpp_properties.json is not plain JSON — add the SDK include paths yourself.");
-    }
-  }
-  const config = { name: CONFIG_NAME, includePath: ["${workspaceFolder}/**", ...includePath], defines, cppStandard: "c++20" };
-  const configs = (props.configurations ?? []).filter((c) => c.name !== CONFIG_NAME);
-  props.configurations = [config, ...configs];
-  mkdirSync(resolve(root, ".vscode"), { recursive: true });
-  writeFileSync(file, JSON.stringify(props, null, 2) + "\n");
-}
+// Editor (IntelliSense) support for C++ backends. The rb_sdk headers only exist inside the dev image,
+// so a host editor flags every SDK name. Copy them to .muscat-dev/sysroot and point
+// .vscode/c_cpp_properties.json at them, using the include dirs / defines rb_sdk's CMake target exports.
+// The build never reads these copies — it runs in the image.
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { cppSdkFiles, log } from "./util.mjs";
+
+const SYSROOT = ".muscat-dev/sysroot";
+const CONFIG_NAME = "Muscat";
+const COPY = ["/usr/include/rainbow", "/usr/include/eigen3", "/usr/lib/cmake/rb_sdk/rb_sdkTargets.cmake"];
+
+function imageId(image) {
+  const r = spawnSync("docker", ["image", "inspect", "-f", "{{.Id}}", image], { encoding: "utf8" });
+  return r.status === 0 ? r.stdout.trim() : null;
+}
+
+/** Copy the SDK headers out of `image` (once per image build) and write the VS Code C/C++ config. */
+export function syncCppIde(root, image) {
+  if (!cppSdkFiles(root).length) return;
+  const id = imageId(image);
+  if (!id) return;
+  const sysroot = resolve(root, SYSROOT);
+  const stamp = resolve(sysroot, ".image-id");
+  if (!existsSync(stamp) || readFileSync(stamp, "utf8") !== id) {
+    rmSync(sysroot, { recursive: true, force: true });
+    const create = spawnSync("docker", ["create", image], { encoding: "utf8" });
+    if (create.status !== 0) return log.warn("could not copy SDK headers for the editor (docker create failed).");
+    const container = create.stdout.trim();
+    try {
+      for (const src of COPY) {
+        const dest = resolve(sysroot, src.slice(1));
+        mkdirSync(resolve(dest, ".."), { recursive: true });
+        spawnSync("docker", ["cp", `${container}:${src}`, dest], { stdio: "ignore" });
+      }
+    } finally {
+      spawnSync("docker", ["rm", container], { stdio: "ignore" });
+    }
+    writeFileSync(stamp, id);
+    log.step(`SDK headers for the editor → ${SYSROOT}`);
+  }
+  writeCppProperties(root, readTarget(sysroot));
+}
+
+// INTERFACE_INCLUDE_DIRECTORIES / INTERFACE_COMPILE_DEFINITIONS of rb_sdk::rb_sdk, mapped into the sysroot.
+function readTarget(sysroot) {
+  const file = resolve(sysroot, "usr/lib/cmake/rb_sdk/rb_sdkTargets.cmake");
+  const text = existsSync(file) ? readFileSync(file, "utf8") : "";
+  const list = (key) => (text.match(new RegExp(`${key} "([^"]*)"`))?.[1] ?? "").split(";").filter(Boolean);
+  const prefix = `\${workspaceFolder}/${SYSROOT}/usr`;
+  const includes = list("INTERFACE_INCLUDE_DIRECTORIES").map((d) => d.replace("${_IMPORT_PREFIX}", prefix));
+  return {
+    includePath: [...(includes.length ? includes : [`${prefix}/include`]), `${prefix}/include/eigen3`],
+    defines: list("INTERFACE_COMPILE_DEFINITIONS"),
+  };
+}
+
+// Keeps other configurations; ours is replaced in place or put first so VS Code picks it by default.
+function writeCppProperties(root, { includePath, defines }) {
+  const file = resolve(root, ".vscode", "c_cpp_properties.json");
+  let props = { configurations: [], version: 4 };
+  if (existsSync(file)) {
+    try {
+      props = JSON.parse(readFileSync(file, "utf8"));
+    } catch {
+      return log.warn(".vscode/c_cpp_properties.json is not plain JSON — add the SDK include paths yourself.");
+    }
+  }
+  const config = { name: CONFIG_NAME, includePath: ["${workspaceFolder}/**", ...includePath], defines, cppStandard: "c++20" };
+  const configs = (props.configurations ?? []).filter((c) => c.name !== CONFIG_NAME);
+  props.configurations = [config, ...configs];
+  mkdirSync(resolve(root, ".vscode"), { recursive: true });
+  writeFileSync(file, JSON.stringify(props, null, 2) + "\n");
+}

package/cli/src/dev.mjs

@@ -1,165 +1,165 @@
-// muscat-pk dev — run the local Muscat runtime (gateway, MediaMTX, common), 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 { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { runDevUi } from "./devUi.mjs";
-import { stopDevBackContainers } from "./devBack.mjs";
-import { ensureLocalMuscat, GATEWAY_PORT, isPortInUse, robotHasMuscat } from "./muscatLocal.mjs";
-import { assertManifestPorts, assertManifestVariables } from "./manifest.mjs";
-import {
-  ensureDocker,
-  ensureIdeVenv,
-  findPluginRoot,
-  log,
-  prompt,
-  promptRobotConnection,
-  venvPython,
-} from "./util.mjs";
-import { ensureRemoteZenohEnv, isRemoteRobot, isWsl } from "./zenohDev.mjs";
-
-const HOST_AGENT_PATH = fileURLToPath(new URL("./host_agent.py", import.meta.url));
-const canAutoStartHostAgent = () => process.platform === "darwin" || process.platform === "win32" || 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` shares the local Muscat 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 = []) {
-  const root = findPluginRoot();
-  assertManifestVariables(root);
-  const portRanges = assertManifestPorts(root);
-  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 — the local Muscat then publishes the zenoh port for it.
-  if (!proxyEndpoint) await ensureRemoteZenohEnv(robotIp, { log });
-
-  // A robot running Muscat is the gateway (:10000) and common for both the UI and the backend.
-  // Otherwise the local Muscat runtime is; the backend joins its netns, so the plugin's declared
-  // ports are published from it too.
-  const muscat = (await robotHasMuscat(robotIp)) ? null : await ensureLocalMuscat({
-    pluginPorts: portRanges,
-    zenohPort: remoteRobot && !proxyEndpoint ? Number(process.env.MUSCAT_ZENOH_PORT) || null : null,
-  }).catch((e) => { log.warn(`local Muscat: ${e.message}`); return null; });
-  if (muscat) {
-    process.env.MUSCAT_PK_MUSCAT_CONTAINER = muscat;
-  } else if (remoteRobot || (await isPortInUse(GATEWAY_PORT))) {
-    // e.g. developing on the robot PC: its Muscat already serves the gateway; the backend reaches it via the host.
-  } else {
-    log.warn(`no local Muscat on :${GATEWAY_PORT} — the plugin UI cannot reach the backend.`);
-    const answer = await prompt("  Proceed anyway? [y/N]: ");
-    if (answer.toLowerCase() !== "y") return;
-  }
-
-  // dev:back in its own process: its docker build / pip install / cmake build are synchronous and would
-  // freeze dev:ui's server on this event loop until they finish (or Ctrl+C killed them).
-  // A Bun binary re-runs itself with just the command; under Node argv[1] is the script.
-  const backend = spawn(process.execPath, [...(typeof Bun === "undefined" ? [process.argv[1]] : []), "dev:back"], {
-    stdio: ["ignore", "inherit", "inherit"],
-  });
-  backend.on("exit", (code) => code && log.warn(`dev:back exited (${code})`));
-
-  process.env.MUSCAT_PK_MANAGED_DEV = "1";
-
-  const cleanup = () => {
-    if (hostAgent && hostAgent.exitCode === null) hostAgent.kill();
-    if (backend.exitCode === null) backend.kill();
-    stopDevBackContainers();
-  };
-  process.once("SIGINT", cleanup);
-  process.once("SIGTERM", cleanup);
-  process.once("SIGHUP", cleanup); // terminal closed (VS Code re-running Dev disposes it)
-  process.once("exit", cleanup);
-
-  await runDevUi(args);
-}
+// muscat-pk dev — run the local Muscat runtime (gateway, MediaMTX, common), 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 { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runDevUi } from "./devUi.mjs";
+import { stopDevBackContainers } from "./devBack.mjs";
+import { ensureLocalMuscat, GATEWAY_PORT, isPortInUse, robotHasMuscat } from "./muscatLocal.mjs";
+import { assertManifestPorts, assertManifestVariables } from "./manifest.mjs";
+import {
+  ensureDocker,
+  ensureIdeVenv,
+  findPluginRoot,
+  log,
+  prompt,
+  promptRobotConnection,
+  venvPython,
+} from "./util.mjs";
+import { ensureRemoteZenohEnv, isRemoteRobot, isWsl } from "./zenohDev.mjs";
+
+const HOST_AGENT_PATH = fileURLToPath(new URL("./host_agent.py", import.meta.url));
+const canAutoStartHostAgent = () => process.platform === "darwin" || process.platform === "win32" || 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` shares the local Muscat 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 = []) {
+  const root = findPluginRoot();
+  assertManifestVariables(root);
+  const portRanges = assertManifestPorts(root);
+  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 — the local Muscat then publishes the zenoh port for it.
+  if (!proxyEndpoint) await ensureRemoteZenohEnv(robotIp, { log });
+
+  // A robot running Muscat is the gateway (:10000) and common for both the UI and the backend.
+  // Otherwise the local Muscat runtime is; the backend joins its netns, so the plugin's declared
+  // ports are published from it too.
+  const muscat = (await robotHasMuscat(robotIp)) ? null : await ensureLocalMuscat({
+    pluginPorts: portRanges,
+    zenohPort: remoteRobot && !proxyEndpoint ? Number(process.env.MUSCAT_ZENOH_PORT) || null : null,
+  }).catch((e) => { log.warn(`local Muscat: ${e.message}`); return null; });
+  if (muscat) {
+    process.env.MUSCAT_PK_MUSCAT_CONTAINER = muscat;
+  } else if (remoteRobot || (await isPortInUse(GATEWAY_PORT))) {
+    // e.g. developing on the robot PC: its Muscat already serves the gateway; the backend reaches it via the host.
+  } else {
+    log.warn(`no local Muscat on :${GATEWAY_PORT} — the plugin UI cannot reach the backend.`);
+    const answer = await prompt("  Proceed anyway? [y/N]: ");
+    if (answer.toLowerCase() !== "y") return;
+  }
+
+  // dev:back in its own process: its docker build / pip install / cmake build are synchronous and would
+  // freeze dev:ui's server on this event loop until they finish (or Ctrl+C killed them).
+  // A Bun binary re-runs itself with just the command; under Node argv[1] is the script.
+  const backend = spawn(process.execPath, [...(typeof Bun === "undefined" ? [process.argv[1]] : []), "dev:back"], {
+    stdio: ["ignore", "inherit", "inherit"],
+  });
+  backend.on("exit", (code) => code && log.warn(`dev:back exited (${code})`));
+
+  process.env.MUSCAT_PK_MANAGED_DEV = "1";
+
+  const cleanup = () => {
+    if (hostAgent && hostAgent.exitCode === null) hostAgent.kill();
+    if (backend.exitCode === null) backend.kill();
+    stopDevBackContainers();
+  };
+  process.once("SIGINT", cleanup);
+  process.once("SIGTERM", cleanup);
+  process.once("SIGHUP", cleanup); // terminal closed (VS Code re-running Dev disposes it)
+  process.once("exit", cleanup);
+
+  await runDevUi(args);
+}