brepjs-verify 0.4.0 → 0.8.0

package/dist/mcp/server.cjs

@@ -0,0 +1,400 @@
+#!/usr/bin/env node
+let node_url = require("node:url");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let node_os = require("node:os");
+let node_child_process = require("node:child_process");
+let node_fs_promises = require("node:fs/promises");
+let _modelcontextprotocol_sdk_server_index_js = require("@modelcontextprotocol/sdk/server/index.js");
+let _modelcontextprotocol_sdk_server_stdio_js = require("@modelcontextprotocol/sdk/server/stdio.js");
+let _modelcontextprotocol_sdk_types_js = require("@modelcontextprotocol/sdk/types.js");
+let node_util = require("node:util");
+let node_crypto = require("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 execFileAsync = (0, node_util.promisify)(node_child_process.execFile);
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_MEMORY_MB = 2048;
+var MAX_OUTPUT_BYTES = 8 * 1024 * 1024;
+/**
+* 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 = (0, node_url.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();
}
", "" + {}.url));
+	if ((0, node_fs.existsSync)(builtJs)) return builtJs;
+	return (0, node_url.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();
}
", "" + {}.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 (0, node_fs_promises.mkdtemp)((0, node_path.join)((0, node_os.tmpdir)(), "brepjs-run-"));
+	try {
+		await (0, node_fs_promises.writeFile)((0, node_path.join)(dir, "package.json"), "{\"type\":\"module\"}\n");
+		const partPath = (0, node_path.join)(dir, "part.brep.ts");
+		await (0, node_fs_promises.writeFile)(partPath, code);
+		const cliArgs = makeArgs(partPath);
+		const cmd = useTsx ? "npx" : process.execPath;
+		const args = 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
+			};
+		}
+	} finally {
+		await (0, node_fs_promises.rm)(dir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+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 = (0, node_crypto.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 (0, node_fs_promises.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).
+*/
+var pkgPath = (0, node_path.join)((0, node_path.dirname)((0, node_url.fileURLToPath)({}.url)), "..", "..", "package.json");
+var server = new _modelcontextprotocol_sdk_server_index_js.Server({
+	name: "brepjs-verify",
+	version: JSON.parse((0, node_fs.readFileSync)(pkgPath, "utf8")).version
+}, { capabilities: { tools: {} } });
+server.setRequestHandler(_modelcontextprotocol_sdk_types_js.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(_modelcontextprotocol_sdk_types_js.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 _modelcontextprotocol_sdk_server_stdio_js.StdioServerTransport());
+}
+main().catch((err) => {
+	console.error("brepjs-verify MCP server failed to start:", err);
+	process.exit(1);
+});
+//#endregion

package/dist/mcp/server.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * 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).
+ */
+export {};