brepjs-verify 0.8.0 → 0.13.0

package/dist/mcp/server.js

@@ -3,12 +3,11 @@ import { fileURLToPath } from "node:url";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { tmpdir } from "node:os";
-import { execFile } from "node:child_process";
+import { spawn } from "node:child_process";
 import { appendFile, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { promisify } from "node:util";
 import { createHash } from "node:crypto";
 //#region src/sandbox/runProgram.ts
 /**
@@ -20,11 +19,22 @@ import { createHash } from "node:crypto";
 * rather than hanging or crashing the host. Results cross the boundary as serialized JSON (never
 * live WASM handles), and the temp program directory is always cleaned up.
 */
-var execFileAsync = promisify(execFile);
 var DEFAULT_TIMEOUT_MS = 3e4;
 var DEFAULT_MAX_MEMORY_MB = 2048;
 var MAX_OUTPUT_BYTES = 8 * 1024 * 1024;
 /**
+* In-flight sandbox process *groups*, keyed by group-leader pid. Tracked so a dying host can reap
+* its runs (see installSandboxShutdownHandlers) — the per-run timeout can't, since its timer dies
+* with the host.
+*/
+var activeGroups = /* @__PURE__ */ new Set();
+/** SIGKILL (or `signal`) an entire detached process group by its leader pid; ignore if already gone. */
+function killGroup(pid, signal) {
+	try {
+		process.kill(process.platform === "win32" ? pid : -pid, signal);
+	} catch {}
+}
+/**
 * Clamp a caller-supplied limit to a positive, finite value, falling back to the default otherwise.
 * Critical for the timeout: Node's `execFile` treats `timeout: 0` (and it ignores negatives) as
 * "no timeout", which would silently disable the sandbox's only runaway protection.
@@ -53,39 +63,14 @@ async function runVerifyCli(code, makeArgs, opts) {
 		const partPath = join(dir, "part.brep.ts");
 		await writeFile(partPath, code);
 		const cliArgs = makeArgs(partPath);
-		const cmd = useTsx ? "npx" : process.execPath;
-		const args = useTsx ? [
+		return await spawnCliOutcome(useTsx ? "npx" : process.execPath, useTsx ? [
 			"tsx",
 			cliEntry,
 			...cliArgs
-		] : [cliEntry, ...cliArgs];
-		try {
-			const { stdout, stderr } = await execFileAsync(cmd, args, {
-				timeout: timeoutMs,
-				killSignal: "SIGKILL",
-				maxBuffer: MAX_OUTPUT_BYTES,
-				env: {
-					...process.env,
-					NODE_OPTIONS: [process.env["NODE_OPTIONS"], `--max-old-space-size=${maxMemoryMb}`].filter(Boolean).join(" ")
-				}
-			});
-			return {
-				stdout,
-				stderr,
-				timedOut: false,
-				outputTooLarge: false,
-				exitCode: 0
-			};
-		} catch (err) {
-			const e = err;
-			return {
-				stdout: e.stdout ?? "",
-				stderr: e.stderr ?? (err instanceof Error ? err.message : String(err)),
-				timedOut: Boolean(e.killed) && e.code !== "ERR_CHILD_PROCESS_STDIO_MAXBUFFER",
-				outputTooLarge: e.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER",
-				exitCode: typeof e.code === "number" ? e.code : null
-			};
-		}
+		] : [cliEntry, ...cliArgs], {
+			...process.env,
+			NODE_OPTIONS: [process.env["NODE_OPTIONS"], `--max-old-space-size=${maxMemoryMb}`].filter(Boolean).join(" ")
+		}, timeoutMs);
 	} finally {
 		await rm(dir, {
 			recursive: true,
@@ -93,6 +78,109 @@ async function runVerifyCli(code, makeArgs, opts) {
 		});
 	}
 }
+/**
+* Spawn the verify CLI in its OWN process group and enforce the wall-clock budget by SIGKILLing the
+* WHOLE group on timeout — not just the direct child.
+*
+* Why a process group rather than Node's built-in `execFile` timeout: in dev/test the CLI runs as
+* `npx tsx <main.ts>`, so the process that actually executes the part (and can spin on a CPU-bound
+* OCCT op) is a *grandchild* behind npx+tsx. `child_process`' `timeout`/`killSignal` signals only
+* the direct child, so a fired timeout SIGKILLs `npx` and orphans the still-spinning grandchild
+* forever (it reparents to init and keeps burning a core). Spawning `detached` makes the child a
+* process-group leader that npx's descendants inherit, so `process.kill(-pid, …)` reaps the entire
+* tree. The production path (`node dist/cli/main.js`) has no intermediary, but the group kill is
+* equally correct there.
+*/
+function spawnCliOutcome(cmd, args, env, timeoutMs) {
+	return new Promise((resolve) => {
+		const child = spawn(cmd, args, {
+			env,
+			detached: true,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		if (child.pid !== void 0) activeGroups.add(child.pid);
+		let stdout = "";
+		let stderr = "";
+		let stdoutBytes = 0;
+		let timedOut = false;
+		let outputTooLarge = false;
+		let settled = false;
+		const killTree = (signal) => {
+			if (child.pid !== void 0) killGroup(child.pid, signal);
+		};
+		const timer = setTimeout(() => {
+			timedOut = true;
+			killTree("SIGKILL");
+		}, timeoutMs);
+		child.stdout?.on("data", (chunk) => {
+			if (outputTooLarge) return;
+			stdoutBytes += chunk.length;
+			if (stdoutBytes > MAX_OUTPUT_BYTES) {
+				outputTooLarge = true;
+				killTree("SIGKILL");
+				return;
+			}
+			stdout += chunk.toString();
+		});
+		let stderrBytes = 0;
+		child.stderr?.on("data", (chunk) => {
+			stderrBytes += chunk.length;
+			if (stderrBytes <= MAX_OUTPUT_BYTES) stderr += chunk.toString();
+		});
+		const finish = (exitCode) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			if (child.pid !== void 0) activeGroups.delete(child.pid);
+			resolve({
+				stdout,
+				stderr,
+				timedOut,
+				outputTooLarge,
+				exitCode
+			});
+		};
+		child.on("error", (err) => {
+			if (!stderr) stderr = err.message;
+			finish(null);
+		});
+		child.on("close", (code) => finish(code));
+	});
+}
+/** SIGKILL every in-flight sandbox process group now. Exported so a host can reap explicitly. */
+function killActiveSandboxes(signal = "SIGKILL") {
+	for (const pid of activeGroups) killGroup(pid, signal);
+	activeGroups.clear();
+}
+var shutdownHandlersInstalled = false;
+/**
+* Install process-shutdown hooks that reap any in-flight sandbox process groups when THIS process
+* (the host — e.g. the MCP server) terminates. Idempotent; call once at startup from an entrypoint.
+*
+* Rationale: the per-run timeout (`spawnCliOutcome`) only protects a run while the host is alive —
+* its timer dies with the host. If the host is stopped (the agent disconnects) before a run's
+* budget elapses, the `detached` sandbox group is in its own session and survives, burning a core
+* indefinitely. These hooks SIGKILL every tracked group on the way down so a dying host doesn't
+* leak its children. (A hard SIGKILL of the host can't be trapped — that residual needs the kernel's
+* PR_SET_PDEATHSIG, which Node doesn't expose.)
+*/
+function installSandboxShutdownHandlers() {
+	if (shutdownHandlersInstalled) return;
+	shutdownHandlersInstalled = true;
+	process.on("exit", () => killActiveSandboxes("SIGKILL"));
+	process.once("SIGTERM", () => {
+		killActiveSandboxes("SIGKILL");
+		process.exit(143);
+	});
+	process.once("SIGINT", () => {
+		killActiveSandboxes("SIGKILL");
+		process.exit(130);
+	});
+}
 function tryParse(out) {
 	if (!out.trim()) return null;
 	try {
@@ -346,6 +434,7 @@ async function exportPartTool(args) {
 * "build → verify" step the agent loop is built on. Uses the SDK's low-level `Server` with plain
 * JSON-Schema tool definitions (no direct zod dependency in this package).
 */
+installSandboxShutdownHandlers();
 var pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
 var server = new Server({
 	name: "brepjs-verify",

package/dist/sandbox/runProgram.d.ts

@@ -53,6 +53,20 @@ export interface ExportFormats {
  * "no timeout", which would silently disable the sandbox's only runaway protection.
  */
 export declare function positiveOrDefault(value: number | undefined, fallback: number): number;
+/** SIGKILL every in-flight sandbox process group now. Exported so a host can reap explicitly. */
+export declare function killActiveSandboxes(signal?: NodeJS.Signals): void;
+/**
+ * Install process-shutdown hooks that reap any in-flight sandbox process groups when THIS process
+ * (the host — e.g. the MCP server) terminates. Idempotent; call once at startup from an entrypoint.
+ *
+ * Rationale: the per-run timeout (`spawnCliOutcome`) only protects a run while the host is alive —
+ * its timer dies with the host. If the host is stopped (the agent disconnects) before a run's
+ * budget elapses, the `detached` sandbox group is in its own session and survives, burning a core
+ * indefinitely. These hooks SIGKILL every tracked group on the way down so a dying host doesn't
+ * leak its children. (A hard SIGKILL of the host can't be trapped — that residual needs the kernel's
+ * PR_SET_PDEATHSIG, which Node doesn't expose.)
+ */
+export declare function installSandboxShutdownHandlers(): void;
 /** Execute `code` (an agent-authored `.brep.ts` module) in an isolated, resource-bounded child. */
 export declare function runProgram(code: string, opts?: RunProgramOptions): Promise<RunProgramResult>;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brepjs-verify",
-  "version": "0.8.0",
+  "version": "0.13.0",
   "description": "Agent skill + verify/preview tooling for authoring parametric brepjs CAD code",
   "license": "Apache-2.0",
   "type": "module",
@@ -53,9 +53,8 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.29.0",
-    "@types/node": "^25.9.1",
     "brepjs": "^18.0.0",
-    "commander": "^13.0.0",
+    "commander": "^15.0.0",
     "occt-wasm": "^3.0.0",
     "typescript": "^6.0.3"
   },
@@ -63,20 +62,20 @@
     "puppeteer": "^25.0.4"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "0.100.1",
+    "@anthropic-ai/sdk": "0.102.0",
     "@react-three/drei": "^10.7.7",
     "@react-three/fiber": "^9.6.1",
-    "@types/node": "^25.9.1",
+    "@types/node": "25.9.2",
     "@types/react": "^19.2.15",
     "@types/react-dom": "^19.2.3",
     "@types/three": "^0.184.1",
     "@vitejs/plugin-react": "^6.0.2",
     "brepjs-viewer": "*",
     "eslint": "^10.4.0",
-    "react": "^19.2.6",
-    "react-dom": "^19.2.6",
+    "react": "19.2.7",
+    "react-dom": "19.2.7",
     "three": "^0.184.0",
-    "tsx": "^4.22.3",
+    "tsx": "4.22.4",
     "vite": "^8.0.0",
     "vite-plugin-dts": "^5.0.1",
     "vitest": "^4.0.0",