@parkhill/mcp-server-for-rhino 0.3.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Robert McNeel & Associates
+Copyright (c) 2026 Parkhill (modifications: Parkhill fork with native geometry tools)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,98 @@
+# @parkhill/mcp-server-for-rhino
+
+An MCP server for modeling in **Rhino 3D** through AI assistants (Claude Desktop, Claude Code, Cursor, and others). It covers Grasshopper, and it also builds geometry directly in the Rhino document.
+
+This is Parkhill's fork of [McNeel's Rhino MCP](https://github.com/mcneel/RhinoMCP), MIT licensed. The fork adds native geometry tools and installs side by side with the official plugin.
+
+## How it works
+
+This npm package is a small launcher. The MCP server itself runs inside a Rhino plugin, the **Parkhill-Rhino-MCP** yak package. The launcher finds that plugin's router and connects your AI client to it.
+
+```
+AI client ──stdio──▶ npx @parkhill/mcp-server-for-rhino ──▶ router (in the yak) ──HTTP──▶ Rhino
+```
+
+If the Rhino plugin isn't installed yet, the server starts with a single `install_parkhill_rhino_mcp` tool. That tool installs the plugin from a local `.yak` file (see below).
+
+## Requirements
+
+- Rhino 8 (Windows or macOS), or Rhino 9 WIP
+- Node.js 18+
+
+## 1. Install the Rhino plugin
+
+Download `parkhill-rhino-mcp-<version>-rh8_*-win.yak` from the [releases page](https://github.com/Parkhill-Smith-Cooper/RhinoMCP/releases), or get it from your team share. Then use one of these:
+
+- Drag the `.yak` onto an open Rhino window and restart Rhino.
+- Set `PARKHILL_RHINO_MCP_YAK` to the `.yak` file, or to the folder that holds it, in the MCP config below. Then ask the assistant to "install the Rhino plugin". The launcher extracts it for you.
+
+## 2. Add the MCP server to your client
+
+**Claude Desktop** (`claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "rhino-parkhill": {
+      "command": "npx",
+      "args": ["-y", "@parkhill/mcp-server-for-rhino", "--default-version", "8"],
+      "env": {
+        "PARKHILL_RHINO_MCP_YAK": "\\\\server\\share\\rhino-mcp"
+      }
+    }
+  }
+}
+```
+
+**Claude Code:**
+
+```sh
+claude mcp add rhino-parkhill -- npx -y @parkhill/mcp-server-for-rhino --default-version 8
+```
+
+The `env` block is optional. It's only needed for the automatic plugin install.
+
+Start Rhino, or let the server launch Rhino for you, and ask the assistant to model something.
+
+## Tools
+
+**Native geometry**
+
+| Tool | Operations |
+|---|---|
+| `create_curve` | line, polyline, curve, interpcrv, rectangle, circle, arc, ellipse |
+| `create_solid` | plane, box, cylinder, sphere |
+| `create_surface` | planar_srf, edge_srf, extrude_crv, extrude_srf, loft, sweep1, sweep2, revolve, cap |
+| `transform_objects` | move, rotate, scale, scale1d, mirror, array_linear, array_rect, array_polar |
+| `edit_geometry` | break, join, trim, split, extend, explode, offset, offset_srf |
+| `boolean_objects` | union, difference, split, boolean_intersection, intersect |
+| `group_objects` | group, ungroup |
+
+Every call:
+- is a single undo step in Rhino
+- returns the ids of the objects it created
+- accepts an optional `layer` and `name` when it creates objects
+
+**Everything from upstream**
+- `run_command`, `run_python`, `run_csharp`
+- selection and object queries, viewport capture and camera
+- document open, save and close
+- Grasshopper 1 and 2 canvas tools
+- multi-Rhino slot management
+
+## Options
+
+| Flag / env | Meaning |
+|---|---|
+| `--default-version 8\|9\|WIP` | Which Rhino to launch when none is running (default 8) |
+| `PARKHILL_RHINO_MCP_YAK` | Path to a `.yak` file, or a folder of them, used by the install fallback |
+| `PARKHILL_RHINO_MCP_RHINO_EXE_8` / `_9` / `_WIP` | Custom Rhino executable path |
+| `PARKHILL_RHINO_MCP_STARTUP_TIMEOUT` | Seconds to wait for a spawned Rhino (default 120) |
+
+## Coexisting with McNeel's plugin
+
+The Parkhill plugin uses its own names and state, so both plugins can be installed at the same time:
+- plugin id and command names (`PHMCPStart`, `PHMCPSpawn`, …)
+- ports, starting at 10600
+- state in `%LOCALAPPDATA%\Parkhill\rhino-mcp`
+- MCP config key `rhino-parkhill`

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@parkhill/mcp-server-for-rhino",
+  "version": "0.3.0",
+  "description": "MCP server for modeling in Rhino 3D (native geometry + Grasshopper) through AI assistants. Parkhill fork of McNeel's Rhino MCP.",
+  "type": "module",
+  "bin": {
+    "mcp-server-for-rhino": "router-launcher.mjs"
+  },
+  "files": [
+    "router-launcher.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "sync": "node sync.mjs",
+    "prepack": "node sync.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "win32",
+    "darwin"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "rhino",
+    "rhino3d",
+    "grasshopper",
+    "cad",
+    "claude"
+  ],
+  "license": "MIT",
+  "author": "Parkhill",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Parkhill-Smith-Cooper/RhinoMCP.git",
+    "directory": "npm"
+  },
+  "homepage": "https://github.com/Parkhill-Smith-Cooper/RhinoMCP#readme",
+  "bugs": {
+    "url": "https://github.com/Parkhill-Smith-Cooper/RhinoMCP/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/router-launcher.mjs

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+// Locate the parkhill-rhino-mcp-router binary inside an installed Parkhill-Rhino-MCP yak
+// and spawn it with our stdio passed through. Yak layout:
+//   <packages>/<rhino-ver>/Parkhill-Rhino-MCP/<pkg-ver>/router/<rid>/parkhill-rhino-mcp-router[.exe]
+// Canonical copy lives here in shared/; the packaging paths each stage their own
+// copy of this file at build time.
+
+import { statSync, readdirSync, readFileSync, writeFileSync, mkdirSync, rmSync, renameSync } from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
+import { join, basename } from "node:path";
+import { homedir, constants as osConstants } from "node:os";
+import { createInterface } from "node:readline";
+
+function resolveRid() {
+  if (process.platform === "darwin") return "osx-arm64";
+  if (process.platform === "win32") return process.arch === "arm64" ? "win-arm64" : "win-x64";
+  return null;
+}
+
+function packagesRoot() {
+  if (process.platform === "darwin") {
+    return join(homedir(), "Library", "Application Support", "McNeel", "Rhinoceros", "packages");
+  }
+  if (process.platform === "win32") {
+    return process.env.APPDATA ? join(process.env.APPDATA, "McNeel", "Rhinoceros", "packages") : null;
+  }
+  return null;
+}
+
+function isDir(p) { try { return statSync(p).isDirectory(); } catch { return false; } }
+function isFile(p) { try { return statSync(p).isFile(); } catch { return false; } }
+function listDirs(p) { try { return readdirSync(p).filter(n => isDir(join(p, n))); } catch { return []; } }
+
+const PACKAGE_NAME = "Parkhill-Rhino-MCP";
+// Path to a .yak file, or a folder of them (a network share, a downloaded
+// GitHub release); the newest one matching the Rhino version wins.
+const LOCAL_YAK_ENV = "PARKHILL_RHINO_MCP_YAK";
+const RELEASES_URL = "https://github.com/Parkhill-Smith-Cooper/RhinoMCP/releases";
+
+// Inspect every installed yak and return the full candidate list (search order)
+// plus the first one whose router binary exists. Callers log the whole list so
+// "why did it pick X" / "why didn't it find anything" is answerable from the
+// MCP server log alone.
+function findRouter() {
+  const rid = resolveRid();
+  const root = packagesRoot();
+  if (!rid || !root) return { rid, root, considered: [], picked: null };
+
+  const exe = process.platform === "win32" ? "parkhill-rhino-mcp-router.exe" : "parkhill-rhino-mcp-router";
+
+  // Numeric-aware reverse sort: 0.10.0 ranks above 0.1.0(lexical would invert).
+  const byVersionDesc = (a, b) => b.localeCompare(a, undefined, { numeric: true });
+
+  const considered = [];
+  for (const ver of ["9.0", "8.0"]) {
+    const base = join(root, ver, PACKAGE_NAME);
+    if (!isDir(base)) continue;
+    for (const pkgver of listDirs(base).sort(byVersionDesc)) {
+      considered.push({ ver, pkgver, path: join(base, pkgver, "router", rid, exe) });
+    }
+  }
+
+  const picked = considered.find(c => isFile(c.path)) ?? null;
+  return { rid, root, exe, considered, picked };
+}
+
+const r = findRouter();
+
+process.stderr.write(`rhino-mcp-launcher: platform=${process.platform}/${process.arch} rid=${r.rid ?? "?"} root=${r.root ?? "?"}\n`);
+
+if (!r.rid || !r.root) {
+  process.stderr.write(`rhino-mcp-launcher: unsupported platform\n`);
+  process.exit(1);
+}
+
+// spawn() can fail two different ways depending on platform:
+//   POSIX  — returns a ChildProcess; ENOENT/EACCES surface as an async `error` event.
+//   Win32  — throws *synchronously* (e.g. `spawn UNKNOWN` on a file with bad PE format).
+// Handle both so the launcher always exits cleanly with code 1 + "spawn failed"
+// rather than dumping an unhandled stack trace.
+function spawnFailed(err) {
+  process.stderr.write(`rhino-mcp-launcher: spawn failed: ${err.message}\n`);
+  process.exit(1);
+}
+
+let child;
+if (r.considered.length === 0) {
+  process.stderr.write(`rhino-mcp-launcher: no Parkhill-Rhino-MCP yak installed under ${r.root}\n`);
+  runInstallFallback("no Parkhill-Rhino-MCP yak is installed");
+} else if (!r.picked) {
+  const summary = r.considered.map(c => `${c.ver}/${c.pkgver}`).join(", ");
+  process.stderr.write(`rhino-mcp-launcher: candidates [${summary}]\n`);
+  process.stderr.write(`rhino-mcp-launcher: no ${r.exe} found for ${r.rid} in any installed yak\n`);
+  runInstallFallback(`installed Parkhill-Rhino-MCP yak has no router/${r.rid}/${r.exe}`);
+} else {
+  const summary = r.considered.map(c => `${c.ver}/${c.pkgver}${c === r.picked ? "*" : ""}`).join(", ");
+  process.stderr.write(`rhino-mcp-launcher: candidates [${summary}] (* = picked)\n`);
+  process.stderr.write(`rhino-mcp-launcher: exec ${r.picked.path}\n`);
+  
+  try {
+    child = spawn(r.picked.path, process.argv.slice(2), {
+      stdio: ["pipe", "pipe", "inherit"],
+      windowsHide: true,
+    });
+  } catch (err) {
+    spawnFailed(err);
+  }
+  if (child) {
+    process.stdin.pipe(child.stdin);
+    // Filter blank lines — Claude Desktop fails the server on a bare newline.
+    const out = createInterface({ input: child.stdout });
+    out.on("line", line => {
+      if (line.trim() === "") return;
+      process.stdout.write(line + "\n");
+    });
+  }
+}
+
+// `error` and `close` can both fire for the same failure (ENOENT,
+// non-executable on POSIX). Gate so we don't mask a spawn failure as exit 0.
+let terminating = false;
+
+if (child) {
+  child.on("error", err => {
+    if (terminating) return;
+    terminating = true;
+    spawnFailed(err);
+  });
+
+  // `close` (not `exit`) so stdio fully drains — `exit` can truncate the
+  // router's final MCP frame on a fast shutdown.
+  child.on("close", (code, signal) => {
+    if (terminating) return;
+    terminating = true;
+    if (signal) {
+      process.exit(128 + (osConstants.signals[signal] ?? 15));
+    } else {
+      process.exit(code ?? 0);
+    }
+  });
+}
+
+// When the router can't be found, we don't just die — we'd surface a red dot
+// in Claude Desktop's MCP list and the user has no way to recover from chat.
+// Instead, start a *placeholder* MCP server that advertises one tool:
+// install_parkhill_rhino_mcp. The user asks Claude to connect to Rhino, the
+// model finds only this tool, and the user gets a chat-native consent prompt
+// to install the yak into their configured Rhino version.
+function parseDefaultVersion(args) {
+  for (let i = 0; i < args.length - 1; i++) {
+    if (args[i] === "--default-version" || args[i] === "-v") return args[i + 1];
+  }
+  return "8";
+}
+
+function resolveYak(version) {
+  // Test override: skip platform-specific probing and use a caller-supplied
+  // path. Lets the launcher tests simulate "Rhino is installed" / "Rhino is
+  // missing" deterministically without depending on what's on the CI runner.
+  const override = process.env.PARKHILL_RHINO_MCP_FAKE_YAK_PATH;
+  if (override != null) return override && isFile(override) ? override : null;
+
+  // "9", "BETA", and "WIP" are the same Rhino 9 family and probe the same
+  // installs in order: prefer the release, then BETA, then WIP.
+  const isRhino9 = version === "9" || version === "BETA" || version === "WIP";
+  if (process.platform === "darwin") {
+    const apps =
+      version === "8" ? ["Rhino 8.app"]
+      : isRhino9 ? ["Rhino 9.app", "RhinoBETA.app", "RhinoWIP.app"]
+      : [];
+    for (const app of apps) {
+      const p = `/Applications/${app}/Contents/Resources/bin/yak`;
+      if (isFile(p)) return p;
+    }
+    return null;
+  }
+  if (process.platform === "win32") {
+    const dirs =
+      version === "8" ? ["Rhino 8"]
+      : isRhino9 ? ["Rhino 9", "Rhino 9 BETA", "Rhino 9 WIP"]
+      : [];
+    for (const dir of dirs) {
+      const p = join("C:\\Program Files", dir, "System", "Yak.exe");
+      if (isFile(p)) return p;
+    }
+    return null;
+  }
+  return null;
+}
+
+// The Parkhill plugin is not on McNeel's public package server, so the install
+// fallback installs a local .yak file instead of running `yak install <name>`.
+function rhinoPackagesDir(version) {
+  return version === "8" ? "8.0" : "9.0";
+}
+
+function resolveLocalYak(version) {
+  const configured = process.env[LOCAL_YAK_ENV];
+  if (!configured) return null;
+  if (isFile(configured)) return configured;
+  if (!isDir(configured)) return null;
+  // yak build names packages <name>-<ver>-rh<major>_<minor>-<platform>.yak.
+  const tag = `rh${version === "8" ? "8" : "9"}`;
+  const platform = process.platform === "darwin" ? "mac" : "win";
+  const byVersionDesc = (a, b) => b.localeCompare(a, undefined, { numeric: true });
+  const candidates = readdirSync(configured)
+    .filter(n => n.toLowerCase().endsWith(".yak") && n.toLowerCase().startsWith(PACKAGE_NAME.toLowerCase()))
+    .filter(n => n.includes(tag) || !/rh\d/.test(n))
+    .filter(n => n.includes(platform) || n.includes("any") || !/-(win|mac)\.yak$/i.test(n))
+    .sort(byVersionDesc);
+  return candidates.length ? join(configured, candidates[0]) : null;
+}
+
+// bsdtar reads zip archives (a .yak is a zip). Windows 10+ ships it in
+// System32; prefer that over a GNU tar that Git for Windows may put on PATH.
+function resolveTar() {
+  if (process.platform === "win32") {
+    const sys = join(process.env.SystemRoot ?? "C:\\Windows", "System32", "tar.exe");
+    if (isFile(sys)) return sys;
+  }
+  return "tar";
+}
+
+// Mirrors what `yak install` leaves on disk:
+//   <packages>/<N>.0/<name>/<pkg-ver>/...   and   <packages>/<N>.0/<name>/manifest.txt = <pkg-ver>
+function installLocalYak(yakPath, version) {
+  const root = packagesRoot();
+  if (!root) throw new Error("unsupported platform");
+  const base = join(root, rhinoPackagesDir(version), PACKAGE_NAME);
+  const staging = join(base, `.staging-${process.pid}`);
+  rmSync(staging, { recursive: true, force: true });
+  mkdirSync(staging, { recursive: true });
+  try {
+    const res = spawnSync(resolveTar(), ["-xf", yakPath, "-C", staging], { encoding: "utf8" });
+    if (res.status !== 0) {
+      throw new Error(`could not extract ${yakPath}: ${(res.stderr || res.error?.message || "").trim()}`);
+    }
+    const manifestPath = join(staging, "manifest.yml");
+    if (!isFile(manifestPath)) throw new Error(`${basename(yakPath)} has no manifest.yml; is it a ${PACKAGE_NAME} .yak?`);
+    const manifest = readFileSync(manifestPath, "utf8");
+    const name = /^name:\s*(\S+)/m.exec(manifest)?.[1];
+    const pkgVer = /^version:\s*(\S+)/m.exec(manifest)?.[1];
+    if (name !== PACKAGE_NAME) throw new Error(`${basename(yakPath)} is package '${name}', expected '${PACKAGE_NAME}'.`);
+    if (!pkgVer) throw new Error(`${basename(yakPath)} manifest.yml has no version.`);
+    const dest = join(base, pkgVer);
+    rmSync(dest, { recursive: true, force: true });
+    renameSync(staging, dest);
+    writeFileSync(join(base, "manifest.txt"), pkgVer);
+    return { dest, pkgVer };
+  } finally {
+    rmSync(staging, { recursive: true, force: true });
+  }
+}
+
+function runInstallFallback(reason) {
+  const version = parseDefaultVersion(process.argv.slice(2));
+
+  // If Rhino itself isn't installed, installing the plugin can't help. Detect
+  // that upfront and surface a different tool that points at the Rhino download page.
+  if (!resolveYak(version)) {
+    runRhinoMissingFallback(version);
+    return;
+  }
+
+  const localYak = resolveLocalYak(version);
+  const how = localYak
+    ? `A local package was found at ${localYak}. Ask the user whether to install it now; if they agree, call this tool with no arguments.`
+    : `No local package is configured. Tell the user to download the ${PACKAGE_NAME} .yak for Rhino ${version} from ${RELEASES_URL} ` +
+      `and either drag it onto the Rhino window, or set the ${LOCAL_YAK_ENV} environment variable of this MCP server to the .yak file (or its folder) and call this tool.`;
+
+  const tool = {
+    name: "install_parkhill_rhino_mcp",
+    description:
+      `The ${PACKAGE_NAME} plugin is not installed in Rhino ${version} (reason: ${reason}). ${how} ` +
+      `After install, restart Rhino if it is open and reload this connector (or restart the MCP client) so the real Rhino tools appear.`,
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+  };
+
+  function doInstall() {
+    const yakPath = resolveLocalYak(version);
+    if (!yakPath) {
+      return {
+        isError: true,
+        content: [{
+          type: "text",
+          text: `No ${PACKAGE_NAME} .yak found. Download it from ${RELEASES_URL}, then drag it onto Rhino ${version}, ` +
+                `or set ${LOCAL_YAK_ENV} to the .yak file or its folder and try again.`,
+        }],
+      };
+    }
+    process.stderr.write(`rhino-mcp-launcher: installing ${yakPath} into Rhino ${version}
+`);
+    try {
+      const { dest, pkgVer } = installLocalYak(yakPath, version);
+      return {
+        content: [{
+          type: "text",
+          text: `Installed ${PACKAGE_NAME} ${pkgVer} into ${dest}. Restart Rhino ${version} if it is open, ` +
+                `then reload this connector (or restart the MCP client) for the Rhino tools to appear.`,
+        }],
+      };
+    } catch (err) {
+      return { isError: true, content: [{ type: "text", text: `Install failed: ${err.message}` }] };
+    }
+  }
+
+  runPlaceholderMcp({
+    mode: `install-fallback mode (version=${version}, reason=${reason})`,
+    serverName: "parkhill-rhino-mcp-installer",
+    tool,
+    onCall: doInstall,
+  });
+}
+
+function runRhinoMissingFallback(version) {
+  const downloadUrl = "https://www.rhino3d.com/download";
+  const tool = {
+    name: "rhino_not_installed",
+    description:
+      `Rhino ${version} does not appear to be installed on this machine, so the Parkhill Rhino MCP connector cannot start. ` +
+      `Tell the user to install Rhino ${version} from ${downloadUrl}, then reload this connector ` +
+      `(or restart Claude Desktop). Calling this tool just repeats the same instructions.`,
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+  };
+
+  runPlaceholderMcp({
+    mode: `rhino-missing-fallback mode (version=${version})`,
+    serverName: "parkhill-rhino-mcp-no-rhino",
+    tool,
+    onCall: () => ({
+      content: [{
+        type: "text",
+        text: `Rhino ${version} is not installed. Download it from ${downloadUrl} and reload this connector once the install finishes.`,
+      }],
+    }),
+  });
+}
+
+function runPlaceholderMcp({ mode, serverName, tool, onCall }) {
+  process.stderr.write(`rhino-mcp-launcher: entering ${mode}\n`);
+
+  const send = msg => process.stdout.write(JSON.stringify(msg) + "\n");
+  const reply = (id, result) => send({ jsonrpc: "2.0", id, result });
+  const error = (id, code, message) => send({ jsonrpc: "2.0", id, error: { code, message } });
+
+  const rl = createInterface({ input: process.stdin });
+  rl.on("line", line => {
+    if (line.trim() === "") return;
+    let req;
+    try { req = JSON.parse(line); } catch { error(null, -32700, "Parse error"); return; }
+    const { id, method, params } = req;
+    // A request without an id is a notification — JSON-RPC 2.0 forbids any
+    // reply, including errors. (id: null is discouraged; treat it the same.)
+    if (id === undefined || id === null) return;
+    if (method === "initialize") {
+      reply(id, {
+        protocolVersion: params?.protocolVersion ?? "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: serverName, version: "0.0.1" },
+      });
+    } else if (method === "tools/list") {
+      reply(id, { tools: [tool] });
+    } else if (method === "tools/call") {
+      if (params?.name !== tool.name) {
+        error(id, -32601, `unknown tool: ${params?.name}`);
+        return;
+      }
+      reply(id, onCall());
+    } else {
+      error(id, -32601, `method not supported in ${mode}: ${method}`);
+    }
+  });
+  rl.on("close", () => process.exit(0));
+  // Keep alive — readline holds stdin open.
+}
+
+// Only SIGTERM is forwarded. SIGINT / SIGHUP from a controlling terminal
+// already reach the router via process-group delivery — forwarding would
+// send a *second* SIGINT, which .NET's host treats as "force quit" and
+// skips the ApplicationStopping hook that closes spawned Rhinos. MCP-protocol
+// shutdown flows through stdin EOF (inherited), not signals.
+process.on("SIGTERM", () => { try { child?.kill("SIGTERM"); } catch { /* child already exited */ } });