@inneranimalmedia/agentsam-sdk 2.6.5 → 2.6.8

package/test/integration/app-command.test.mjs

@@ -1,85 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import test from 'node:test';
-import { listAppManifests } from '../../src/commands/app.js';
-
-test('lists agentsam.app.json manifests for product apps', () => {
-  const apps = listAppManifests();
-  const ids = apps.map((row) => row.id).sort();
-  assert.ok(ids.includes('cad-creator'));
-  assert.ok(ids.includes('local-studio'));
-  assert.ok(ids.includes('client-cms-editor'));
-  assert.ok(ids.includes('ecommerce-cms-agentsam'));
-});
-
-test('agentsam app validate passes for all product apps', async () => {
-  const { validateApps } = await import('../../src/commands/app.js');
-  const report = validateApps();
-  assert.equal(report.ok, true, report.errors.join('\n'));
-  assert.ok(report.apps.length >= 4);
-});
-
-test('CMS app scaffold source is included in the SDK distribution contract', async () => {
-  const { validateApps } = await import('../../src/commands/app.js');
-  const report = validateApps({ appId: 'client-cms-editor' });
-  assert.equal(report.ok, true, report.errors.join('\n'));
-  assert.deepEqual(report.warnings, []);
-});
-
-test('CAD and CMS workers load APP identity from agentsam.app.json', () => {
-  const cad = fs.readFileSync(path.resolve('apps/cad-creator/backend/worker/index.js'), 'utf8');
-  const cms = fs.readFileSync(path.resolve('apps/client-cms-editor/backend/worker/index.js'), 'utf8');
-  assert.match(cad, /import appManifest from ['"]\.\.\/\.\.\/agentsam\.app\.json['"]/);
-  assert.match(cms, /import appManifest from ['"]\.\.\/\.\.\/agentsam\.app\.json['"]/);
-  assert.doesNotMatch(cad, /const\s+APP\s*=\s*["']/);
-  assert.doesNotMatch(cms, /const\s+APP\s*=\s*["']/);
-});
-
-test('desktop CMS shell app_id resolves to client-cms-editor', () => {
-  const manifest = JSON.parse(
-    fs.readFileSync(path.resolve('packages/agentsam-desktop-shell/manifests/cms-editor.json'), 'utf8'),
-  );
-  assert.equal(manifest.app_id, 'client-cms-editor');
-});
-
-
-test('Ecommerce CMS app bin exposes truthful runnable doctor state', () => {
-  const bin = path.resolve('apps/ecommerce-cms-agentsam/bin/agentsam-ecommerce.mjs');
-  const result = spawnSync(process.execPath, [bin, 'doctor', '--json'], {
-    cwd: path.resolve('.'),
-    encoding: 'utf8',
-  });
-
-  assert.equal(result.status, 0, result.stderr);
-  const report = JSON.parse(result.stdout);
-  assert.equal(report.app_id, 'ecommerce-cms-agentsam');
-  assert.equal(report.source.frontend, true);
-  assert.equal(report.runtime.package_json, true);
-  assert.equal(report.runtime.runnable, true);
-  assert.equal(report.manifest_runtime.local_preview, 'ready');
-  assert.equal(report.manifest_runtime.source_scaffold, 'ready');
-  assert.equal(report.contract_consistent, true);
-});
-
-test('Ecommerce CMS app manifest and package agree on executable preview', () => {
-  const manifest = JSON.parse(
-    fs.readFileSync(path.resolve('apps/ecommerce-cms-agentsam/agentsam.app.json'), 'utf8'),
-  );
-  const pkg = JSON.parse(
-    fs.readFileSync(path.resolve('apps/ecommerce-cms-agentsam/package.json'), 'utf8'),
-  );
-  const frontendPkg = JSON.parse(
-    fs.readFileSync(path.resolve('apps/ecommerce-cms-agentsam/frontend/package.json'), 'utf8'),
-  );
-
-  assert.equal(manifest.package, pkg.name);
-  assert.equal(manifest.bin, 'bin/agentsam-ecommerce.mjs');
-  assert.equal(manifest.runtime.local_preview, 'ready');
-  assert.equal(manifest.runtime.source_scaffold, 'ready');
-  assert.equal(manifest.preview.entry, '/admin');
-  assert.equal(manifest.preview.port, 4174);
-  assert.equal(typeof pkg.scripts.preview, 'string');
-  assert.equal(typeof frontendPkg.scripts.preview, 'string');
-});

package/test/integration/cad-discovery.test.mjs

@@ -1,158 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  discoverOpenScad,
-  openScadStatus,
-  discoverFreeCad,
-  freeCadStatus,
-  meshyStatus,
-  mujocoStatus,
-  discoverAllCadTools,
-  getInstallGuidance,
-} from '../../src/lib/cad/index.js';
-
-function makeFixture(t, name) {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), `agentsam-${name}-test-`));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const binary = path.join(root, process.platform === 'win32' ? `${name}.exe` : name);
-  fs.writeFileSync(binary, `fake ${name}\n`);
-  return { root, binary };
-}
-
-test('discoverOpenScad honors explicit binary before env and path', (t) => {
-  const { binary } = makeFixture(t, 'openscad');
-  const result = discoverOpenScad({
-    openscadBin: binary,
-    env: { AGENTSAM_OPENSCAD_BIN: '/nonexistent/bin' },
-  });
-  assert.equal(result.source, 'explicit');
-  assert.equal(result.binary, fs.realpathSync(binary));
-});
-
-test('discoverOpenScad honors AGENTSAM_OPENSCAD_BIN when explicit is not set', (t) => {
-  const { binary } = makeFixture(t, 'openscad');
-  const result = discoverOpenScad({
-    env: { AGENTSAM_OPENSCAD_BIN: binary },
-  });
-  assert.equal(result.source, 'env');
-  assert.equal(result.binary, fs.realpathSync(binary));
-});
-
-test('openScadStatus probes version boundedly and returns deterministic receipt', async (t) => {
-  const { binary } = makeFixture(t, 'openscad');
-  const calls = [];
-  const status = await openScadStatus({
-    openscadBin: binary,
-    runProcessImpl: async (command, args) => {
-      calls.push({ command, args });
-      return { code: 0, stdout: '', stderr: 'OpenSCAD version 2026.04.26\n' };
-    },
-  });
-
-  assert.equal(status.tool, 'openscad');
-  assert.equal(status.available, true);
-  assert.equal(status.version, '2026.04.26');
-  assert.equal(status.execution_lane, 'native');
-  assert.deepEqual(calls[0], { command: fs.realpathSync(binary), args: ['-v'] });
-});
-
-test('discoverFreeCad honors explicit binary and AGENTSAM_FREECAD_BIN', (t) => {
-  const { binary } = makeFixture(t, 'FreeCADCmd');
-  const result = discoverFreeCad({
-    freecadBin: binary,
-    env: { AGENTSAM_FREECAD_BIN: '/nonexistent/path' },
-  });
-  assert.equal(result.source, 'explicit');
-  assert.equal(result.binary, fs.realpathSync(binary));
-
-  const envResult = discoverFreeCad({
-    env: { AGENTSAM_FREECAD_BIN: binary },
-  });
-  assert.equal(envResult.source, 'env');
-  assert.equal(envResult.binary, fs.realpathSync(binary));
-});
-
-test('freeCadStatus probes version and returns deterministic receipt', async (t) => {
-  const { binary } = makeFixture(t, 'FreeCADCmd');
-  const calls = [];
-  const status = await freeCadStatus({
-    freecadBin: binary,
-    runProcessImpl: async (command, args) => {
-      calls.push({ command, args });
-      return { code: 0, stdout: 'FreeCAD 1.1.1 Revision: 20260414 (Git shallow)\n', stderr: '' };
-    },
-  });
-
-  assert.equal(status.tool, 'freecad');
-  assert.equal(status.available, true);
-  assert.equal(status.version, 'FreeCAD 1.1.1 Revision: 20260414 (Git shallow)');
-  assert.equal(status.execution_lane, 'native');
-  assert.deepEqual(calls[0], { command: fs.realpathSync(binary), args: ['--version'] });
-});
-
-test('meshyStatus discovers API key configuration via environment', () => {
-  const noKey = meshyStatus({ env: {} });
-  assert.equal(noKey.available, false);
-  assert.equal(noKey.source, 'none');
-  assert.equal(noKey.execution_lane, 'cloud_byok');
-
-  const withKey = meshyStatus({ env: { MESHY_API_KEY: 'msy_test_secret_key' } });
-  assert.equal(withKey.available, true);
-  assert.equal(withKey.source, 'env');
-  assert.equal(withKey.version, 'v2-api');
-});
-
-test('mujocoStatus returns browser WASM bundled capability', () => {
-  const status = mujocoStatus();
-  assert.equal(status.tool, 'mujoco');
-  assert.equal(status.available, true);
-  assert.equal(status.execution_lane, 'browser_wasm');
-});
-
-test('discoverAllCadTools aggregates deterministic receipts across engines', async (t) => {
-  const { binary: openscad } = makeFixture(t, 'openscad');
-  const { binary: freecad } = makeFixture(t, 'FreeCADCmd');
-  const { binary: blender } = makeFixture(t, 'blender');
-
-  const report = await discoverAllCadTools({
-    openscadBin: openscad,
-    freecadBin: freecad,
-    blenderBin: blender,
-    env: { MESHY_API_KEY: 'test_key' },
-    runProcessImpl: async (command, args) => {
-      if (args[0] === '-v') return { code: 0, stdout: '', stderr: 'OpenSCAD version 2026.04.26\n' };
-      if (command.includes('FreeCAD')) return { code: 0, stdout: 'FreeCAD 1.1.1 Revision: 20260414\n', stderr: '' };
-      return { code: 0, stdout: 'Blender 5.0.1\n', stderr: '' };
-    },
-  });
-
-  assert.equal(report.schema_version, 1);
-  assert.equal(report.total_tools, 5);
-  assert.equal(report.available_tools, 5);
-  assert.equal(report.all_systems_ready, true);
-  assert.equal(report.tools.length, 5);
-});
-
-test('getInstallGuidance provides exact OS package manager commands', () => {
-  const darwinOpenScad = getInstallGuidance('openscad', 'darwin');
-  assert.equal(darwinOpenScad.command, 'brew install openscad');
-
-  const linuxFreeCad = getInstallGuidance('freecad', 'linux');
-  assert.match(linuxFreeCad.command, /apt-get install.*freecad/);
-
-  const winBlender = getInstallGuidance('blender', 'win32');
-  assert.equal(winBlender.command, 'winget install BlenderFoundation.Blender');
-});
-
-test('discoverOpenScad returns binary: null when not found on host (no hardcoded defaults)', () => {
-  const emptyDiscovery = discoverOpenScad({
-    env: { PATH: '' },
-    platform: 'unknown_os',
-  });
-  assert.equal(emptyDiscovery.binary, null);
-  assert.equal(emptyDiscovery.source, 'none');
-});
-

package/test/integration/cad-docker-executor.test.mjs

@@ -1,249 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import http from 'node:http';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  DEFAULT_CAD_DOCKER_PORT,
-  DEFAULT_CAD_DOCKER_URL,
-  resolveDockerServiceConfig,
-  probeDockerServiceHealth,
-  executeOpenScadDocker,
-  executeFreeCadDocker,
-  executeBlenderDocker,
-} from '../../src/lib/cad/docker-executor.js';
-import { discoverAllCadTools } from '../../src/lib/cad/discovery.js';
-
-test('resolveDockerServiceConfig resolves URL and token from env or options', () => {
-  const conf1 = resolveDockerServiceConfig({
-    serviceUrl: 'http://custom-host:9999/',
-    token: 'secret-token-123',
-  });
-  assert.equal(conf1.url, 'http://custom-host:9999');
-  assert.equal(conf1.token, 'secret-token-123');
-
-  const conf2 = resolveDockerServiceConfig({
-    env: {
-      AGENTSAM_CAD_SERVICE_URL: 'http://env-host:8888',
-      AGENTSAM_CAD_TOKEN: 'env-tok',
-    },
-  });
-  assert.equal(conf2.url, 'http://env-host:8888');
-  assert.equal(conf2.token, 'env-tok');
-
-  const confDefault = resolveDockerServiceConfig({ env: {} });
-  assert.equal(confDefault.url, DEFAULT_CAD_DOCKER_URL);
-  assert.equal(confDefault.token, null);
-});
-
-test('probeDockerServiceHealth returns offline gracefully when unreachable', async () => {
-  const result = await probeDockerServiceHealth({
-    serviceUrl: 'http://127.0.0.1:54321', // Unused port
-    timeoutMs: 150,
-  });
-  assert.equal(result.available, false);
-  assert.equal(result.url, 'http://127.0.0.1:54321');
-});
-
-test('Docker CAD service executor routes compile, build, and inspect requests', async () => {
-  const recordedRequests = [];
-  const mockServer = http.createServer((req, res) => {
-    let body = '';
-    req.on('data', chunk => { body += chunk; });
-    req.on('end', () => {
-      recordedRequests.push({
-        url: req.url,
-        method: req.method,
-        auth: req.headers['authorization'],
-        body: body ? JSON.parse(body) : null,
-      });
-
-      if (req.url === '/healthz') {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-          ok: true,
-          service: 'agentsam-cad',
-          version: '1',
-          tools: {
-            openscad: { installed: true, version: 'OpenSCAD 2021.01-docker' },
-            freecad: { installed: true, version: 'FreeCAD 0.21.2-docker' },
-            blender: { installed: true, version: 'Blender 4.2.0-docker' },
-          },
-        }));
-        return;
-      }
-
-      if (req.url === '/v1/openscad/compile') {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-          ok: true,
-          tool: 'openscad',
-          format: 'stl',
-          filename: 'bracket.stl',
-          size_bytes: 128,
-          sha256: 'abc123sha',
-          artifact_base64: Buffer.from('solid bracket\nendsolid').toString('base64'),
-          logs: ['[DOCKER] OpenSCAD compiled successfully'],
-        }));
-        return;
-      }
-
-      if (req.url === '/v1/freecad/execute') {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-          ok: true,
-          tool: 'freecad',
-          format: 'step',
-          filename: 'part.step',
-          size_bytes: 512,
-          sha256: 'step123sha',
-          artifact_base64: Buffer.from('ISO-10303-21;').toString('base64'),
-          metrics: { volume: 1500, surface_area: 800, faces_count: 6 },
-          logs: ['[DOCKER] FreeCAD built STEP model'],
-        }));
-        return;
-      }
-
-      if (req.url === '/v1/blender/execute') {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-          ok: true,
-          tool: 'blender',
-          operation: 'build',
-          format: 'glb',
-          filename: 'scene.glb',
-          size_bytes: 1024,
-          sha256: 'glb123sha',
-          artifact_base64: Buffer.from('glTF binary mock').toString('base64'),
-          result: { ok: true, blender_version: '4.2.0', objects: ['Cube', 'Camera'] },
-          logs: ['[DOCKER] Blender rendered glb scene'],
-        }));
-        return;
-      }
-
-      res.writeHead(404, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ ok: false, error: 'not_found' }));
-    });
-  });
-
-  await new Promise((resolve) => mockServer.listen(0, '127.0.0.1', resolve));
-  const port = mockServer.address().port;
-  const serviceUrl = `http://127.0.0.1:${port}`;
-  const token = 'test-token-xyz';
-
-  try {
-    // 1. Health probe
-    const health = await probeDockerServiceHealth({ serviceUrl, token });
-    assert.equal(health.available, true);
-    assert.equal(health.tools.openscad.installed, true);
-    assert.equal(health.tools.freecad.installed, true);
-    assert.equal(health.tools.blender.installed, true);
-
-    // 2. OpenSCAD execution
-    const oscadRes = await executeOpenScadDocker({
-      source: 'cube([10, 10, 10]);',
-      outputFormat: 'stl',
-      filename: 'bracket.stl',
-      serviceUrl,
-      token,
-    });
-    assert.equal(oscadRes.success, true);
-    assert.equal(oscadRes.filename, 'bracket.stl');
-    assert.match(oscadRes.artifactContent, /solid bracket/);
-    assert.equal(oscadRes.mimeType, 'model/stl');
-
-    // 3. FreeCAD execution
-    const freecadRes = await executeFreeCadDocker({
-      operations: [{ op: 'box', length: 10, width: 10, height: 10 }],
-      format: 'step',
-      filename: 'part.step',
-      serviceUrl,
-      token,
-    });
-    assert.equal(freecadRes.success, true);
-    assert.equal(freecadRes.format, 'step');
-    assert.equal(freecadRes.metrics.volume, 1500);
-    assert.match(freecadRes.artifactText, /ISO-10303-21;/);
-
-    // 4. Blender execution
-    const blenderRes = await executeBlenderDocker({
-      operation: 'build',
-      operations: [{ op: 'add', primitive: 'cube' }],
-      format: 'glb',
-      serviceUrl,
-      token,
-    });
-    assert.equal(blenderRes.success, true);
-    assert.equal(blenderRes.format, 'glb');
-    assert.equal(blenderRes.result.blender_version, '4.2.0');
-
-    // 5. Verify recorded request signatures
-    assert.equal(recordedRequests[0].url, '/healthz');
-    assert.equal(recordedRequests[0].auth, 'Bearer test-token-xyz');
-    assert.equal(recordedRequests[1].url, '/v1/openscad/compile');
-    assert.equal(recordedRequests[2].url, '/v1/freecad/execute');
-    assert.equal(recordedRequests[3].url, '/v1/blender/execute');
-  } finally {
-    await new Promise((resolve) => mockServer.close(resolve));
-  }
-});
-
-test('discoverAllCadTools adopts Docker service execution lane when host tools are absent', async () => {
-  const mockServer = http.createServer((req, res) => {
-    if (req.url === '/healthz') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        ok: true,
-        service: 'agentsam-cad',
-        version: '1',
-        tools: {
-          openscad: { installed: true, version: 'OpenSCAD 2021.01-docker' },
-          freecad: { installed: true, version: 'FreeCAD 0.21.2-docker' },
-          blender: { installed: true, version: 'Blender 4.2.0-docker' },
-        },
-      }));
-      return;
-    }
-    res.writeHead(404);
-    res.end();
-  });
-
-  await new Promise((resolve) => mockServer.listen(0, '127.0.0.1', resolve));
-  const port = mockServer.address().port;
-  const serviceUrl = `http://127.0.0.1:${port}`;
-
-  try {
-    const report = await discoverAllCadTools({
-      openscadBin: '/nonexistent/openscad',
-      freecadBin: '/nonexistent/freecad',
-      blenderBin: '/nonexistent/blender',
-      env: {
-        AGENTSAM_CAD_SERVICE_URL: serviceUrl,
-        PATH: '/empty',
-      },
-      cache: false,
-    });
-
-    const openscad = report.tools.find(t => t.tool === 'openscad');
-    const freecad = report.tools.find(t => t.tool === 'freecad');
-    const blender = report.tools.find(t => t.tool === 'blender');
-
-    assert.equal(openscad.available, true);
-    assert.equal(openscad.execution_lane, 'docker_service');
-    assert.equal(openscad.source, 'docker_service');
-    assert.match(openscad.binary, /^docker:\/\//);
-
-    assert.equal(freecad.available, true);
-    assert.equal(freecad.execution_lane, 'docker_service');
-    assert.equal(freecad.source, 'docker_service');
-    assert.match(freecad.binary, /^docker:\/\//);
-
-    assert.equal(blender.available, true);
-    assert.equal(blender.execution_lane, 'docker_service');
-    assert.equal(blender.source, 'docker_service');
-    assert.match(blender.binary, /^docker:\/\//);
-  } finally {
-    await new Promise((resolve) => mockServer.close(resolve));
-  }
-});

package/test/integration/cad-execution.test.mjs

@@ -1,184 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  openScadCompile,
-  validateOpenScadSource,
-  freeCadBuild,
-  freeCadInspect,
-  blenderBuild,
-  blenderInspect,
-  blenderExport,
-  discoverAllCadTools,
-} from '../../src/lib/cad/index.js';
-
-// These tests exercise real local CAD/3D engine binaries (OpenSCAD, FreeCAD,
-// Blender). They are not installed on the generic CI runner and are heavy
-// desktop applications — deliberately not force-installed there (matches
-// the local-first storage/tooling stance elsewhere in this repo). Each
-// execution test below skips itself with a clear reason when its engine
-// isn't present, rather than failing CI for an environment gap. On a
-// machine that has the tool installed (e.g. local dev), the test runs for
-// real with the full original assertions, unchanged.
-const cadReport = await discoverAllCadTools();
-const toolAvailable = (name) => cadReport.tools.find((t) => t.tool === name)?.available === true;
-
-test('CAD Tool Discovery identifies local engines on the machine (schema is always validated; per-tool availability is informational)', async () => {
-  const report = await discoverAllCadTools();
-  assert.equal(report.schema_version, 1);
-  assert.ok(report.total_tools >= 5);
-
-  for (const toolName of ['openscad', 'freecad', 'blender']) {
-    const tool = report.tools.find((t) => t.tool === toolName);
-    assert.ok(tool, `${toolName} entry missing from discovery report`);
-    assert.equal(typeof tool.available, 'boolean');
-    if (tool.available) {
-      assert.ok(tool.binary, `${toolName} reported available but has no binary path`);
-      assert.ok(tool.version, `${toolName} reported available but has no version`);
-    } else {
-      assert.ok(tool.install_guidance, `${toolName} reported unavailable but has no install_guidance`);
-    }
-  }
-});
-
-test('OpenSCAD execution rejects security-violating scripts', async () => {
-  assert.throws(
-    () => validateOpenScadSource('use <child_process>;'),
-    /Security Violation/
-  );
-  assert.throws(
-    () => validateOpenScadSource('exec("cat /etc/passwd");'),
-    /Security Violation/
-  );
-  assert.throws(
-    () => validateOpenScadSource('import("../../secret.scad");'),
-    /Security Violation/
-  );
-});
-
-test('OpenSCAD real compilation produces watertight geometry and returns typed receipt', { skip: !toolAvailable('openscad') && 'openscad binary not available on this machine' }, async (t) => {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-openscad-test-'));
-  t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-  const source = `
-    difference() {
-      cube([width, depth, height], center=true);
-      cylinder(h=height + 2, r=holeRadius, center=true, $fn=24);
-    }
-  `;
-
-  const result = await openScadCompile({
-    source,
-    outputFormat: 'stl',
-    parameters: {
-      width: 30,
-      depth: 20,
-      height: 10,
-      holeRadius: 4,
-    },
-    filename: 'flange.stl',
-  });
-
-  assert.equal(result.success, true);
-  assert.equal(result.engine, 'openscad-native');
-  assert.equal(result.filename, 'flange.stl');
-  assert.equal(result.outputFormat, 'stl');
-  assert.equal(result.mimeType, 'model/stl');
-  assert.ok(result.sizeBytes > 0);
-  assert.ok(result.artifactContent.includes('solid OpenSCAD_Model'));
-  assert.ok(result.artifactContent.includes('facet normal'));
-  assert.ok(result.artifactContent.includes('outer loop'));
-  assert.ok(result.logs.some(l => l.includes('[KERNEL] OpenSCAD Native Compiler')));
-});
-
-test('FreeCAD solid kernel executes precision B-Rep operations and exports valid ISO STEP', { skip: !toolAvailable('freecad') && 'freecad binary not available on this machine' }, async (t) => {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-freecad-test-'));
-  t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-  const stepOutput = path.join(tmpDir, 'bracket.step');
-
-  const recipe = {
-    operations: [
-      { op: 'box', name: 'main_block', length: 40.0, width: 25.0, height: 12.0 },
-      { op: 'cylinder', name: 'bore', radius: 5.0, height: 14.0, translate: [20.0, 12.5, -1.0] },
-      { op: 'cut', base: 'main_block', tool: 'bore' },
-    ],
-  };
-
-  const buildResult = await freeCadBuild({
-    recipe,
-    output: stepOutput,
-    format: 'step',
-  });
-
-  assert.equal(buildResult.ok, true);
-  assert.equal(buildResult.capability, 'freecad.build');
-  assert.equal(buildResult.format, 'step');
-  assert.ok(buildResult.sizeBytes > 0);
-  assert.ok(fs.existsSync(stepOutput));
-
-  // Verify solid shape metrics
-  const expectedSolidVolume = 40.0 * 25.0 * 12.0 - Math.PI * 25.0 * 12.0;
-  assert.ok(Math.abs(buildResult.metrics.volume - expectedSolidVolume) < 1.0, 'Volume matches geometry');
-  assert.equal(buildResult.metrics.faces_count, 7);
-
-  // Read raw STEP content to verify ISO-10303 signature
-  const stepText = fs.readFileSync(stepOutput, 'utf8');
-  assert.ok(stepText.includes('ISO-10303-21;'));
-  assert.ok(stepText.includes('Open CASCADE STEP processor'));
-
-  // Inspect the exported STEP file using FreeCAD inspection
-  const inspectResult = await freeCadInspect({ input: stepOutput });
-  assert.equal(inspectResult.ok, true);
-  assert.equal(inspectResult.capability, 'freecad.inspect');
-  assert.ok(Math.abs(inspectResult.metrics.volume - expectedSolidVolume) < 1.0);
-  assert.equal(inspectResult.metrics.faces_count, 7);
-});
-
-test('Blender real execution builds, inspects, and exports production 3D assets', { skip: !toolAvailable('blender') && 'blender binary not available on this machine' }, async (t) => {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-blender-test-'));
-  t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-  const blendPath = path.join(tmpDir, 'scene.blend');
-  const glbPath = path.join(tmpDir, 'scene.glb');
-
-  const recipe = {
-    schema_version: 1,
-    operations: [
-      { op: 'clear_scene' },
-      { op: 'add', primitive: 'cylinder', name: 'Pillar', radius: 1.5, depth: 4.0 },
-      { op: 'add_light', light_type: 'SUN', energy: 2.5 },
-    ],
-  };
-
-  // 1. Build .blend file
-  const buildResult = await blenderBuild({
-    recipe,
-    output: blendPath,
-  });
-
-  assert.equal(buildResult.ok, true);
-  assert.equal(buildResult.capability, 'blender.build');
-  assert.ok(fs.existsSync(blendPath));
-  assert.ok(buildResult.objects.includes('Pillar'));
-
-  // 2. Inspect built scene
-  const inspectResult = await blenderInspect({ input: blendPath });
-  assert.equal(inspectResult.ok, true);
-  assert.equal(inspectResult.capability, 'blender.inspect');
-  assert.ok(inspectResult.scene.objects.some(o => o.name === 'Pillar'));
-
-  // 3. Export to GLB
-  const exportResult = await blenderExport({
-    input: blendPath,
-    output: glbPath,
-    format: 'glb',
-  });
-
-  assert.equal(exportResult.ok, true);
-  assert.equal(exportResult.capability, 'blender.export');
-  assert.ok(fs.existsSync(glbPath));
-  assert.ok(fs.statSync(glbPath).size > 0);
-});