brepjs-verify 0.4.0 → 0.13.0

package/dist/mcp/server.js

@@ -0,0 +1,489 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
+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 { createHash } from "node:crypto";
+//#region src/sandbox/runProgram.ts
+/**
+* Sandbox executor — run agent-authored brepjs TypeScript in an isolated child process.
+*
+* The program is written to a temp ESM directory and executed by the verify CLI in a separate
+* process, with a wall-clock timeout and a memory cap. Out-of-process execution is what makes the
+* loop *unattended-safe*: a runaway (CPU-bound infinite loop) or memory-hungry part is killed
+* 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 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.
+*/
+function positiveOrDefault(value, fallback) {
+	return value !== void 0 && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function defaultCliEntry() {
+	const builtJs = fileURLToPath(new URL("data:video/mp2t;base64,#!/usr/bin/env node
import { Command } from 'commander';
import { writeFileSync, watch as fsWatch, realpathSync } from 'node:fs';
import { resolve, join, basename, dirname } from 'node:path';
import { tmpdir } from 'node:os';
import { fileURLToPath } from 'node:url';
import { runPart } from '../verify/runPart.js';
import { pushError, reportOk, serializeReport } from '../verify/report.js';
import { runMeasure } from '../verify/measure.js';
import { runDiff } from '../verify/diff.js';
import { scaffoldPart } from './scaffold.js';
import { debounce, DEFAULT_DEBOUNCE_MS } from './watch.js';
import { exportPart } from './exportPart.js';
import { openBrowser, shouldAutoOpen } from './openBrowser.js';
import { disposeShape } from '../disposeShape.js';
import type { shoot as ShootFn } from '../snapshot/shoot.js';

// OCCT's WASM STEP writer emits a "Statistics on Transfer" banner via console.log
// (Emscripten's default stdout sink). The CLI owns stdout for machine-readable JSON,
// so divert that kernel chatter to stderr to keep stdout a single clean JSON document.
// eslint-disable-next-line no-console -- reroute kernel stdout chatter off the JSON channel
console.log = (...args: unknown[]) => {
  process.stderr.write(args.map(String).join(' ') + '\n');
};

export async function loadSnapshotShoot(): Promise<typeof ShootFn | undefined> {
  try {
    const mod = await import('../snapshot/shoot.js');
    return mod.shoot;
  } catch {
    process.stderr.write('snapshots need puppeteer/Chrome — run: npm i puppeteer\n');
    process.exitCode = 1;
    return undefined;
  }
}

const program = new Command();
program.name('brepjs-verify');

program
  .command('verify', { isDefault: true })
  .argument('<file>', 'path to a .brep.ts module with a default-exported part function')
  .option('--step <out>', 'write the primary STEP artifact to this path')
  .option('--glb <out>', 'write a derived GLB preview to this path')
  .option('--json <out>', 'write the JSON report to this path')
  .option(
    '--check',
    'type-check the part (against brepjs types) before running; skip execution on type errors'
  )
  .option('--snapshot <dir>', 'render iso/front/top/right PNGs to this dir (requires built viewer)')
  .option(
    '--serve',
    'after verifying, start a preview server and print a ?dir=&file= deep link (stays running)'
  )
  .option('--no-open', 'with --serve, do not auto-open the browser (just print the viewer URL)')
  .action(
    async (
      file: string,
      opts: {
        step?: string;
        glb?: string;
        json?: string;
        check?: boolean;
        snapshot?: string;
        serve?: boolean;
        // Commander materializes a negated flag as a concrete boolean: true by
        // default, false when --no-open is passed.
        open: boolean;
      }
    ) => {
      // The WASM viewer loads a CAD file (it can't run a .brep.ts), so --snapshot/--serve
      // stage the primary STEP and point the viewer at it via ?dir=&file=. --glb is its own artifact.
      const wantStep = Boolean(opts.step) || Boolean(opts.snapshot) || Boolean(opts.serve);
      const { report, step, glb, shape } = await runPart(resolve(file), {
        step: wantStep,
        glb: Boolean(opts.glb),
        check: Boolean(opts.check),
      });
      let stepPath: string | undefined = opts.step;
      try {
        if (opts.glb && glb) writeFileSync(opts.glb, Buffer.from(glb));

        if (wantStep && step) {
          stepPath = opts.step ?? join(tmpdir(), `brepjs-verify-${basename(file)}.step`);
          writeFileSync(stepPath, Buffer.from(step));
        }
        if (opts.snapshot && stepPath) {
          const shoot = await loadSnapshotShoot(); // lazy: keeps puppeteer off the default path
          if (shoot) {
            const { pngs } = await shoot({ file: stepPath, outDir: opts.snapshot });
            // Diagnostic paths go to stderr — stdout stays a single clean JSON document.
            for (const p of pngs) process.stderr.write(`snapshot: ${p}\n`);
          }
        } else if (opts.snapshot) {
          process.stderr.write('snapshot skipped: STEP export produced no artifact\n');
        }
      } catch (e) {
        pushError(report, { message: `artifact write failed: ${(e as Error).message}` });
      } finally {
        // The shape is a live WASM handle; release it before the server takes over (the
        // --serve path stays running, so leaking here would persist for the server's lifetime).
        disposeShape(shape);
      }
      // Serialize once after all artifact writes so the --json file and stdout
      // reflect the same report (incl. any "artifact write failed" error).
      const json = serializeReport(report);
      if (opts.json) writeFileSync(opts.json, json);
      process.stdout.write(json + '\n');
      if (!reportOk(report)) process.exitCode = 1;
      const willServe = Boolean(opts.serve) && stepPath !== undefined && reportOk(report);
      if (willServe && stepPath) {
        const { serve } = await import('../snapshot/serve.js'); // lazy: no server deps on the default path
        const { url, reused } = await serve({ file: stepPath }); // builds a ?dir=&file= URL; server runs until Ctrl-C
        process.stderr.write(`viewer: ${url}\n`);
        // Auto-open only for a freshly started server (a reused one already has
        // a tab) in an interactive session; `--no-open` (opts.open === false)
        // always suppresses it.
        if (!reused && opts.open && shouldAutoOpen()) {
          openBrowser(url);
        }
      }
    }
  );

program
  .command('measure')
  .argument('<a>', 'path to a .brep.ts module')
  .argument('[b]', 'optional second module; if given, measures distance between the two parts')
  .action(async (a: string, b?: string) => {
    const result = await runMeasure(resolve(a), b === undefined ? undefined : resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('diff')
  .argument('<a>', 'path to the baseline .brep.ts module')
  .argument('<b>', 'path to the comparison .brep.ts module')
  .action(async (a: string, b: string) => {
    const result = await runDiff(resolve(a), resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('init')
  .argument('<name>', 'part name; scaffolds <name>.brep.ts + tsconfig.json + README.md')
  .option('--out <dir>', 'target directory (defaults to ./<name>)')
  .action((name: string, opts: { out?: string }) => {
    const dir = resolve(opts.out ?? name);
    const result = scaffoldPart(name, dir);
    for (const f of result.files) {
      const tag = f.created ? 'created' : 'exists (kept)';
      process.stderr.write(`${tag}: ${f.path}\n`);
    }
    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
  });

program
  .command('watch')
  .argument('<file>', 'path to a .brep.ts module; re-verifies on each save until Ctrl-C')
  .action((file: string) => {
    const path = resolve(file);
    const run = async () => {
      try {
        const { report, shape } = await runPart(path);
        try {
          process.stdout.write(serializeReport(report) + '\n');
        } finally {
          disposeShape(shape); // live WASM handle; the loop runs indefinitely
        }
      } catch (e) {
        process.stderr.write(`watch run failed: ${(e as Error).message}\n`);
      }
    };
    const { trigger } = debounce(run, DEFAULT_DEBOUNCE_MS);
    process.stderr.write(`watching ${path} (Ctrl-C to stop)\n`);
    void run(); // initial verify
    // Watch the parent dir: editors often replace the file (rename) on save,
    // which drops a watcher bound to the file inode itself.
    const watcher = fsWatch(dirname(path), (_event, filename) => {
      if (filename === undefined || filename === null) {
        trigger();
        return;
      }
      if (basename(path) === filename.toString()) trigger();
    });
    const stop = () => {
      watcher.close();
      process.exit(0);
    };
    process.on('SIGINT', stop);
    process.on('SIGTERM', stop); // supervisors (docker stop, systemctl) send SIGTERM
  });

program
  .command('export')
  .argument('<file>', 'path to a .brep.ts module')
  .option('--step', 'write a STEP artifact')
  .option('--glb', 'write a GLB artifact')
  .option('--stl', 'write an STL artifact')
  .option('--all', 'write STEP + GLB + STL')
  .option('--out <dir>', 'output directory', '.')
  .action(
    async (
      file: string,
      opts: { step?: boolean; glb?: boolean; stl?: boolean; all?: boolean; out: string }
    ) => {
      const formats = opts.all
        ? { step: true, glb: true, stl: true }
        : { step: Boolean(opts.step), glb: Boolean(opts.glb), stl: Boolean(opts.stl) };
      if (!formats.step && !formats.glb && !formats.stl) {
        process.stderr.write('no formats requested — pass --step/--glb/--stl or --all\n');
        process.exitCode = 1;
        return;
      }
      const result = await exportPart(resolve(file), formats, resolve(opts.out));
      for (const p of result.written) process.stderr.write(`wrote: ${p}\n`);
      for (const e of result.errors) process.stderr.write(`error: ${e}\n`);
      process.stdout.write(
        JSON.stringify({ ok: result.ok, written: result.written, errors: result.errors }, null, 2) +
          '\n'
      );
      if (!result.ok) process.exitCode = 1;
    }
  );

// Only drive the CLI when run as the entry script, so tests can import the
// guarded loaders without commander parsing the test runner's argv.
// Resolve symlinks on both sides: the npm-installed bin (node_modules/.bin/brepjs)
// is a symlink, so process.argv[1] would otherwise never equal the real module path.
export function isEntrypoint(argv1: string | undefined, moduleUrl: string): boolean {
  if (!argv1) return false;
  try {
    return realpathSync(argv1) === realpathSync(fileURLToPath(moduleUrl));
  } catch {
    return false;
  }
}

if (isEntrypoint(process.argv[1], import.meta.url)) {
  void program.parseAsync();
}
", "" + import.meta.url));
+	if (existsSync(builtJs)) return builtJs;
+	return fileURLToPath(new URL("data:video/mp2t;base64,#!/usr/bin/env node
import { Command } from 'commander';
import { writeFileSync, watch as fsWatch, realpathSync } from 'node:fs';
import { resolve, join, basename, dirname } from 'node:path';
import { tmpdir } from 'node:os';
import { fileURLToPath } from 'node:url';
import { runPart } from '../verify/runPart.js';
import { pushError, reportOk, serializeReport } from '../verify/report.js';
import { runMeasure } from '../verify/measure.js';
import { runDiff } from '../verify/diff.js';
import { scaffoldPart } from './scaffold.js';
import { debounce, DEFAULT_DEBOUNCE_MS } from './watch.js';
import { exportPart } from './exportPart.js';
import { openBrowser, shouldAutoOpen } from './openBrowser.js';
import { disposeShape } from '../disposeShape.js';
import type { shoot as ShootFn } from '../snapshot/shoot.js';

// OCCT's WASM STEP writer emits a "Statistics on Transfer" banner via console.log
// (Emscripten's default stdout sink). The CLI owns stdout for machine-readable JSON,
// so divert that kernel chatter to stderr to keep stdout a single clean JSON document.
// eslint-disable-next-line no-console -- reroute kernel stdout chatter off the JSON channel
console.log = (...args: unknown[]) => {
  process.stderr.write(args.map(String).join(' ') + '\n');
};

export async function loadSnapshotShoot(): Promise<typeof ShootFn | undefined> {
  try {
    const mod = await import('../snapshot/shoot.js');
    return mod.shoot;
  } catch {
    process.stderr.write('snapshots need puppeteer/Chrome — run: npm i puppeteer\n');
    process.exitCode = 1;
    return undefined;
  }
}

const program = new Command();
program.name('brepjs-verify');

program
  .command('verify', { isDefault: true })
  .argument('<file>', 'path to a .brep.ts module with a default-exported part function')
  .option('--step <out>', 'write the primary STEP artifact to this path')
  .option('--glb <out>', 'write a derived GLB preview to this path')
  .option('--json <out>', 'write the JSON report to this path')
  .option(
    '--check',
    'type-check the part (against brepjs types) before running; skip execution on type errors'
  )
  .option('--snapshot <dir>', 'render iso/front/top/right PNGs to this dir (requires built viewer)')
  .option(
    '--serve',
    'after verifying, start a preview server and print a ?dir=&file= deep link (stays running)'
  )
  .option('--no-open', 'with --serve, do not auto-open the browser (just print the viewer URL)')
  .action(
    async (
      file: string,
      opts: {
        step?: string;
        glb?: string;
        json?: string;
        check?: boolean;
        snapshot?: string;
        serve?: boolean;
        // Commander materializes a negated flag as a concrete boolean: true by
        // default, false when --no-open is passed.
        open: boolean;
      }
    ) => {
      // The WASM viewer loads a CAD file (it can't run a .brep.ts), so --snapshot/--serve
      // stage the primary STEP and point the viewer at it via ?dir=&file=. --glb is its own artifact.
      const wantStep = Boolean(opts.step) || Boolean(opts.snapshot) || Boolean(opts.serve);
      const { report, step, glb, shape } = await runPart(resolve(file), {
        step: wantStep,
        glb: Boolean(opts.glb),
        check: Boolean(opts.check),
      });
      let stepPath: string | undefined = opts.step;
      try {
        if (opts.glb && glb) writeFileSync(opts.glb, Buffer.from(glb));

        if (wantStep && step) {
          stepPath = opts.step ?? join(tmpdir(), `brepjs-verify-${basename(file)}.step`);
          writeFileSync(stepPath, Buffer.from(step));
        }
        if (opts.snapshot && stepPath) {
          const shoot = await loadSnapshotShoot(); // lazy: keeps puppeteer off the default path
          if (shoot) {
            const { pngs } = await shoot({ file: stepPath, outDir: opts.snapshot });
            // Diagnostic paths go to stderr — stdout stays a single clean JSON document.
            for (const p of pngs) process.stderr.write(`snapshot: ${p}\n`);
          }
        } else if (opts.snapshot) {
          process.stderr.write('snapshot skipped: STEP export produced no artifact\n');
        }
      } catch (e) {
        pushError(report, { message: `artifact write failed: ${(e as Error).message}` });
      } finally {
        // The shape is a live WASM handle; release it before the server takes over (the
        // --serve path stays running, so leaking here would persist for the server's lifetime).
        disposeShape(shape);
      }
      // Serialize once after all artifact writes so the --json file and stdout
      // reflect the same report (incl. any "artifact write failed" error).
      const json = serializeReport(report);
      if (opts.json) writeFileSync(opts.json, json);
      process.stdout.write(json + '\n');
      if (!reportOk(report)) process.exitCode = 1;
      const willServe = Boolean(opts.serve) && stepPath !== undefined && reportOk(report);
      if (willServe && stepPath) {
        const { serve } = await import('../snapshot/serve.js'); // lazy: no server deps on the default path
        const { url, reused } = await serve({ file: stepPath }); // builds a ?dir=&file= URL; server runs until Ctrl-C
        process.stderr.write(`viewer: ${url}\n`);
        // Auto-open only for a freshly started server (a reused one already has
        // a tab) in an interactive session; `--no-open` (opts.open === false)
        // always suppresses it.
        if (!reused && opts.open && shouldAutoOpen()) {
          openBrowser(url);
        }
      }
    }
  );

program
  .command('measure')
  .argument('<a>', 'path to a .brep.ts module')
  .argument('[b]', 'optional second module; if given, measures distance between the two parts')
  .action(async (a: string, b?: string) => {
    const result = await runMeasure(resolve(a), b === undefined ? undefined : resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('diff')
  .argument('<a>', 'path to the baseline .brep.ts module')
  .argument('<b>', 'path to the comparison .brep.ts module')
  .action(async (a: string, b: string) => {
    const result = await runDiff(resolve(a), resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('init')
  .argument('<name>', 'part name; scaffolds <name>.brep.ts + tsconfig.json + README.md')
  .option('--out <dir>', 'target directory (defaults to ./<name>)')
  .action((name: string, opts: { out?: string }) => {
    const dir = resolve(opts.out ?? name);
    const result = scaffoldPart(name, dir);
    for (const f of result.files) {
      const tag = f.created ? 'created' : 'exists (kept)';
      process.stderr.write(`${tag}: ${f.path}\n`);
    }
    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
  });

program
  .command('watch')
  .argument('<file>', 'path to a .brep.ts module; re-verifies on each save until Ctrl-C')
  .action((file: string) => {
    const path = resolve(file);
    const run = async () => {
      try {
        const { report, shape } = await runPart(path);
        try {
          process.stdout.write(serializeReport(report) + '\n');
        } finally {
          disposeShape(shape); // live WASM handle; the loop runs indefinitely
        }
      } catch (e) {
        process.stderr.write(`watch run failed: ${(e as Error).message}\n`);
      }
    };
    const { trigger } = debounce(run, DEFAULT_DEBOUNCE_MS);
    process.stderr.write(`watching ${path} (Ctrl-C to stop)\n`);
    void run(); // initial verify
    // Watch the parent dir: editors often replace the file (rename) on save,
    // which drops a watcher bound to the file inode itself.
    const watcher = fsWatch(dirname(path), (_event, filename) => {
      if (filename === undefined || filename === null) {
        trigger();
        return;
      }
      if (basename(path) === filename.toString()) trigger();
    });
    const stop = () => {
      watcher.close();
      process.exit(0);
    };
    process.on('SIGINT', stop);
    process.on('SIGTERM', stop); // supervisors (docker stop, systemctl) send SIGTERM
  });

program
  .command('export')
  .argument('<file>', 'path to a .brep.ts module')
  .option('--step', 'write a STEP artifact')
  .option('--glb', 'write a GLB artifact')
  .option('--stl', 'write an STL artifact')
  .option('--all', 'write STEP + GLB + STL')
  .option('--out <dir>', 'output directory', '.')
  .action(
    async (
      file: string,
      opts: { step?: boolean; glb?: boolean; stl?: boolean; all?: boolean; out: string }
    ) => {
      const formats = opts.all
        ? { step: true, glb: true, stl: true }
        : { step: Boolean(opts.step), glb: Boolean(opts.glb), stl: Boolean(opts.stl) };
      if (!formats.step && !formats.glb && !formats.stl) {
        process.stderr.write('no formats requested — pass --step/--glb/--stl or --all\n');
        process.exitCode = 1;
        return;
      }
      const result = await exportPart(resolve(file), formats, resolve(opts.out));
      for (const p of result.written) process.stderr.write(`wrote: ${p}\n`);
      for (const e of result.errors) process.stderr.write(`error: ${e}\n`);
      process.stdout.write(
        JSON.stringify({ ok: result.ok, written: result.written, errors: result.errors }, null, 2) +
          '\n'
      );
      if (!result.ok) process.exitCode = 1;
    }
  );

// Only drive the CLI when run as the entry script, so tests can import the
// guarded loaders without commander parsing the test runner's argv.
// Resolve symlinks on both sides: the npm-installed bin (node_modules/.bin/brepjs)
// is a symlink, so process.argv[1] would otherwise never equal the real module path.
export function isEntrypoint(argv1: string | undefined, moduleUrl: string): boolean {
  if (!argv1) return false;
  try {
    return realpathSync(argv1) === realpathSync(fileURLToPath(moduleUrl));
  } catch {
    return false;
  }
}

if (isEntrypoint(process.argv[1], import.meta.url)) {
  void program.parseAsync();
}
", "" + import.meta.url));
+}
+/**
+* Write `code` to a temp ESM directory, run the verify CLI with `makeArgs(partPath)` in a
+* resource-bounded child process, and return the raw outcome. The temp *program* directory is
+* always cleaned up; any artifacts the CLI writes elsewhere (e.g. an `--out` dir) are the caller's.
+*/
+async function runVerifyCli(code, makeArgs, opts) {
+	const timeoutMs = positiveOrDefault(opts.timeoutMs, DEFAULT_TIMEOUT_MS);
+	const maxMemoryMb = positiveOrDefault(opts.maxMemoryMb, DEFAULT_MAX_MEMORY_MB);
+	const cliEntry = opts.cliEntry ?? defaultCliEntry();
+	const useTsx = cliEntry.endsWith(".ts");
+	const dir = await mkdtemp(join(tmpdir(), "brepjs-run-"));
+	try {
+		await writeFile(join(dir, "package.json"), "{\"type\":\"module\"}\n");
+		const partPath = join(dir, "part.brep.ts");
+		await writeFile(partPath, code);
+		const cliArgs = makeArgs(partPath);
+		return await spawnCliOutcome(useTsx ? "npx" : process.execPath, useTsx ? [
+			"tsx",
+			cliEntry,
+			...cliArgs
+		] : [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,
+			force: true
+		});
+	}
+}
+/**
+* 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 {
+		return JSON.parse(out);
+	} catch {
+		return null;
+	}
+}
+/** Execute `code` (an agent-authored `.brep.ts` module) in an isolated, resource-bounded child. */
+async function runProgram(code, opts = {}) {
+	const o = await runVerifyCli(code, (partPath) => [partPath, "--check"], opts);
+	const report = tryParse(o.stdout);
+	if (report) return {
+		outcome: "completed",
+		report
+	};
+	if (o.timedOut) return {
+		outcome: "timeout",
+		timeoutMs: positiveOrDefault(opts.timeoutMs, DEFAULT_TIMEOUT_MS)
+	};
+	if (o.outputTooLarge) return {
+		outcome: "crashed",
+		exitCode: null,
+		detail: "output exceeded size limit"
+	};
+	return {
+		outcome: "crashed",
+		exitCode: o.exitCode,
+		detail: o.stderr.slice(0, 2e3) || "no JSON report on stdout"
+	};
+}
+/**
+* Execute `code` and export artifacts to `outDir`. Artifacts persist in `outDir` (the caller owns
+* it); only the temp program directory is cleaned up. Returns the written paths and any errors.
+*/
+async function exportProgram(code, outDir, formats = {
+	step: true,
+	glb: true,
+	stl: true
+}, opts = {}) {
+	const formatFlags = [
+		formats.step ? "--step" : "",
+		formats.glb ? "--glb" : "",
+		formats.stl ? "--stl" : ""
+	].filter(Boolean);
+	if (formatFlags.length === 0) return {
+		outcome: "crashed",
+		exitCode: 1,
+		detail: "no formats selected; pass at least one of step/glb/stl"
+	};
+	const o = await runVerifyCli(code, (partPath) => [
+		"export",
+		partPath,
+		...formatFlags,
+		"--out",
+		outDir
+	], opts);
+	const parsed = tryParse(o.stdout);
+	if (parsed) return {
+		outcome: "completed",
+		ok: parsed.ok,
+		written: parsed.written,
+		errors: parsed.errors
+	};
+	if (o.timedOut) return {
+		outcome: "timeout",
+		timeoutMs: positiveOrDefault(opts.timeoutMs, DEFAULT_TIMEOUT_MS)
+	};
+	if (o.outputTooLarge) return {
+		outcome: "crashed",
+		exitCode: null,
+		detail: "output exceeded size limit"
+	};
+	return {
+		outcome: "crashed",
+		exitCode: o.exitCode,
+		detail: o.stderr.slice(0, 2e3) || "no JSON result on stdout"
+	};
+}
+//#endregion
+//#region src/sandbox/runRecord.ts
+/**
+* Run-record — a lightweight, append-only provenance envelope for sandbox executions.
+*
+* Every `run_program` call can emit one JSONL record capturing what ran and what came back
+* (program source, outcome, validity, the content-addressed result hash, and the geometric
+* summary). It is deliberately small and side-channel: it keeps a dataset/eval option open
+* (program → outcome pairs) without changing the agent-facing contract.
+*/
+/** Build a {@link RunRecord} from a program and its sandbox result. `now` is injectable for tests. */
+function buildRunRecord(program, result, now = () => /* @__PURE__ */ new Date()) {
+	const ok = result.outcome === "completed" && result.report.ok;
+	const measurements = result.outcome === "completed" ? result.report.measurements : void 0;
+	const topology = result.outcome === "completed" ? result.report.topology : void 0;
+	const digest = JSON.stringify({
+		outcome: result.outcome,
+		ok,
+		measurements,
+		topology
+	});
+	const resultHash = createHash("sha256").update(`${program}${digest}`).digest("hex");
+	return {
+		timestamp: now().toISOString(),
+		program,
+		outcome: result.outcome,
+		ok,
+		resultHash,
+		...measurements !== void 0 ? { measurements } : {},
+		...topology !== void 0 ? { topology } : {}
+	};
+}
+/** Append a record as one JSON line to `filePath` (creating it if absent). */
+async function appendRunRecord(filePath, record) {
+	await appendFile(filePath, `${JSON.stringify(record)}\n`);
+}
+//#endregion
+//#region src/mcp/tools.ts
+/** JSON Schema for `run_program` input (the low-level Server API takes plain JSON Schema). */
+var RUN_PROGRAM_INPUT_SCHEMA = {
+	type: "object",
+	properties: {
+		code: {
+			type: "string",
+			description: "A brepjs .brep.ts module with a default-exported part function."
+		},
+		timeoutMs: {
+			type: "number",
+			description: "Optional wall-clock budget in milliseconds (default 30000)."
+		}
+	},
+	required: ["code"]
+};
+/**
+* Execute an agent-authored brepjs program in the sandbox and return its verification report.
+* `isError` is set when the part failed checks, timed out, or crashed — so the agent can branch.
+*/
+async function runProgramTool(args) {
+	if (!args.code || !args.code.trim()) return {
+		content: [{
+			type: "text",
+			text: "run_program requires a non-empty \"code\" string."
+		}],
+		isError: true
+	};
+	const result = await runProgram(args.code, args.timeoutMs !== void 0 ? { timeoutMs: args.timeoutMs } : {});
+	const recordPath = process.env["BREPJS_RUN_RECORD_PATH"];
+	if (recordPath) appendRunRecord(recordPath, buildRunRecord(args.code, result)).catch((err) => {
+		console.warn(`run-record append failed (BREPJS_RUN_RECORD_PATH=${recordPath}):`, err);
+	});
+	if (result.outcome === "completed") {
+		const payload = {
+			outcome: "completed",
+			ok: result.report.ok,
+			report: result.report
+		};
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(payload, null, 2)
+			}],
+			isError: !result.report.ok
+		};
+	}
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}],
+		isError: true
+	};
+}
+/** JSON Schema for `export_part` input. */
+var EXPORT_PART_INPUT_SCHEMA = {
+	type: "object",
+	properties: {
+		code: {
+			type: "string",
+			description: "A brepjs .brep.ts module with a default-exported part function."
+		},
+		outDir: {
+			type: "string",
+			description: "Directory to write artifacts into."
+		},
+		formats: {
+			type: "object",
+			description: "Which artifacts to write; omit for all.",
+			properties: {
+				step: { type: "boolean" },
+				glb: { type: "boolean" },
+				stl: { type: "boolean" }
+			}
+		},
+		timeoutMs: {
+			type: "number",
+			description: "Optional wall-clock budget in ms (default 30000)."
+		}
+	},
+	required: ["code", "outDir"]
+};
+/**
+* Build a part in the sandbox and export it to `outDir` (STEP/GLB/STL). Returns the written paths;
+* `isError` is set when the export produced no valid solid, timed out, or crashed. The artifacts
+* persist in `outDir` for the agent to hand off.
+*/
+async function exportPartTool(args) {
+	if (!args.code || !args.code.trim()) return {
+		content: [{
+			type: "text",
+			text: "export_part requires a non-empty \"code\" string."
+		}],
+		isError: true
+	};
+	if (!args.outDir || !args.outDir.trim()) return {
+		content: [{
+			type: "text",
+			text: "export_part requires an \"outDir\" string."
+		}],
+		isError: true
+	};
+	const result = await exportProgram(args.code, args.outDir, args.formats, args.timeoutMs !== void 0 ? { timeoutMs: args.timeoutMs } : {});
+	if (result.outcome === "completed") {
+		const payload = {
+			outcome: "completed",
+			ok: result.ok,
+			written: result.written,
+			errors: result.errors
+		};
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(payload, null, 2)
+			}],
+			isError: !result.ok
+		};
+	}
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}],
+		isError: true
+	};
+}
+//#endregion
+//#region src/mcp/server.ts
+/**
+* brepjs-verify MCP server (stdio).
+*
+* Exposes the verify substrate to MCP-capable agents. The first tool, `run_program`, executes an
+* agent-authored brepjs program in the sandbox and returns the verification report — the closed
+* "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",
+	version: JSON.parse(readFileSync(pkgPath, "utf8")).version
+}, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: [{
+	name: "run_program",
+	description: "Execute an agent-authored brepjs program in an isolated sandbox and return the verification report (validity, measurements, topology). Use this to build a part and check it in one step.",
+	inputSchema: RUN_PROGRAM_INPUT_SCHEMA
+}, {
+	name: "export_part",
+	description: "Build a brepjs part in the sandbox and export it to a directory (STEP/GLB/STL). Use this to hand off the final artifact once a part verifies.",
+	inputSchema: EXPORT_PART_INPUT_SCHEMA
+}] }));
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+	if (req.params.name === "run_program") {
+		const a = req.params.arguments ?? {};
+		const code = typeof a["code"] === "string" ? a["code"] : "";
+		const timeoutMs = typeof a["timeoutMs"] === "number" && a["timeoutMs"] > 0 ? a["timeoutMs"] : void 0;
+		return runProgramTool({
+			code,
+			...timeoutMs !== void 0 ? { timeoutMs } : {}
+		});
+	}
+	if (req.params.name === "export_part") {
+		const a = req.params.arguments ?? {};
+		const code = typeof a["code"] === "string" ? a["code"] : "";
+		const outDir = typeof a["outDir"] === "string" ? a["outDir"] : "";
+		const timeoutMs = typeof a["timeoutMs"] === "number" && a["timeoutMs"] > 0 ? a["timeoutMs"] : void 0;
+		const f = typeof a["formats"] === "object" && a["formats"] !== null ? a["formats"] : void 0;
+		const formats = f && (f["step"] === true || f["glb"] === true || f["stl"] === true) ? {
+			...f["step"] === true ? { step: true } : {},
+			...f["glb"] === true ? { glb: true } : {},
+			...f["stl"] === true ? { stl: true } : {}
+		} : void 0;
+		return exportPartTool({
+			code,
+			outDir,
+			...formats !== void 0 ? { formats } : {},
+			...timeoutMs !== void 0 ? { timeoutMs } : {}
+		});
+	}
+	throw new Error(`Unknown tool: ${req.params.name}`);
+});
+async function main() {
+	await server.connect(new StdioServerTransport());
+}
+main().catch((err) => {
+	console.error("brepjs-verify MCP server failed to start:", err);
+	process.exit(1);
+});
+//#endregion

package/dist/mcp/tools.d.ts

@@ -0,0 +1,77 @@
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { ExportFormats } from '../sandbox/runProgram.js';
+export interface RunProgramToolArgs {
+    /** A brepjs `.brep.ts` module source with a default-exported part function. */
+    code: string;
+    /** Optional wall-clock budget in ms (default 30000). */
+    timeoutMs?: number;
+}
+/** JSON Schema for `run_program` input (the low-level Server API takes plain JSON Schema). */
+export declare const RUN_PROGRAM_INPUT_SCHEMA: {
+    type: "object";
+    properties: {
+        code: {
+            type: string;
+            description: string;
+        };
+        timeoutMs: {
+            type: string;
+            description: string;
+        };
+    };
+    required: string[];
+};
+/**
+ * Execute an agent-authored brepjs program in the sandbox and return its verification report.
+ * `isError` is set when the part failed checks, timed out, or crashed — so the agent can branch.
+ */
+export declare function runProgramTool(args: RunProgramToolArgs): Promise<CallToolResult>;
+export interface ExportPartToolArgs {
+    /** A brepjs `.brep.ts` module source with a default-exported part function. */
+    code: string;
+    /** Directory to write artifacts into (the caller owns it; artifacts persist there). */
+    outDir: string;
+    /** Which formats to write (default: all of STEP/GLB/STL). */
+    formats?: ExportFormats;
+    timeoutMs?: number;
+}
+/** JSON Schema for `export_part` input. */
+export declare const EXPORT_PART_INPUT_SCHEMA: {
+    type: "object";
+    properties: {
+        code: {
+            type: string;
+            description: string;
+        };
+        outDir: {
+            type: string;
+            description: string;
+        };
+        formats: {
+            type: string;
+            description: string;
+            properties: {
+                step: {
+                    type: string;
+                };
+                glb: {
+                    type: string;
+                };
+                stl: {
+                    type: string;
+                };
+            };
+        };
+        timeoutMs: {
+            type: string;
+            description: string;
+        };
+    };
+    required: string[];
+};
+/**
+ * Build a part in the sandbox and export it to `outDir` (STEP/GLB/STL). Returns the written paths;
+ * `isError` is set when the export produced no valid solid, timed out, or crashed. The artifacts
+ * persist in `outDir` for the agent to hand off.
+ */
+export declare function exportPartTool(args: ExportPartToolArgs): Promise<CallToolResult>;