@inneranimalmedia/agentsam-sdk 2.6.1 → 2.6.3

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

@@ -0,0 +1,249 @@
+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

@@ -0,0 +1,184 @@
+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);
+});

package/test/integration/cad-project-app.test.mjs

@@ -0,0 +1,31 @@
+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 {spawn} from 'node:child_process';
+import {localProjectRuntime} from '../../src/lib/cad/project-cli.js';
+test('packaged app API shares CLI revisions, emits events and rejects stale writes',{skip:process.env.AGENTSAM_TEST_CAD_APP!=='1'},async t=>{
+ const root=fs.mkdtempSync(path.join(os.tmpdir(),'cad-app-proof-')),port=31987;
+ const app=new URL('../../apps/cad-creator/backend/',import.meta.url);
+ const child=spawn(process.execPath,['dist/server.mjs'],{cwd:app,env:{...process.env,NODE_ENV:'production',PORT:String(port),HOST:'127.0.0.1',AGENTSAM_CAD_PROJECT_ROOT:root},stdio:['ignore','pipe','pipe']});
+ let log='';child.stdout.on('data',d=>log+=d);child.stderr.on('data',d=>log+=d);
+ t.after(()=>{child.kill();fs.rmSync(root,{recursive:true,force:true});});
+ const base='http://127.0.0.1:'+port;
+ let ready=false;
+ for(let i=0;i<80;i++){try{const r=await fetch(base);if(r.ok){ready=true;break;}}catch{}await new Promise(r=>setTimeout(r,100));}
+ assert.ok(ready,log);
+ async function call(name,input){const res=await fetch(base+'/api/cad/project/tools/'+name,{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify(input)});return {status:res.status,body:await res.json()};}
+ const project=JSON.parse(fs.readFileSync(new URL('../fixtures/cad/courtyard-house.json',import.meta.url),'utf8'));
+ const saved=await call('design_project_save',{project,expected_revision:0});assert.equal(saved.status,200);
+ const runtime=localProjectRuntime(root);assert.equal((await runtime.execute('design_project_get',{project_id:project.id})).content_hash,saved.body.result.content_hash);
+ const abort=new AbortController();t.after(()=>abort.abort());
+ const events=await fetch(base+'/api/cad/project/events',{signal:abort.signal});const reader=events.body.getReader();
+ const edited=await runtime.execute('design_apply_operation',{project_id:project.id,expected_revision:1,operation:{type:'update_wall',wallId:'wall-0',updates:{height3D:132}}});
+ const event=await Promise.race([reader.read(),new Promise((_,reject)=>setTimeout(()=>reject(new Error('event timeout')),5000))]);
+ assert.match(new TextDecoder().decode(event.value),/"revision":2/);
+ const reopened=await call('design_project_get',{project_id:project.id,expected_content_hash:edited.content_hash});assert.equal(reopened.body.result.revision,2);
+ assert.equal((await call('design_project_save',{project,expected_revision:1})).status,409);
+ const denied=await fetch(base+'/api/cad/project/tools/design_project_get',{method:'POST',headers:{'content-type':'application/json',origin:'https://other.example'},body:JSON.stringify({project_id:project.id})});assert.equal(denied.status,403);
+ abort.abort();
+});

package/test/integration/cad-project-d1.test.mjs

@@ -0,0 +1,25 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import {DatabaseSync} from 'node:sqlite';
+import {D1ProjectStore} from '../../src/lib/cad/d1-project-store.js';
+const schema="CREATE TABLE designstudio_design_blueprints (\n  id TEXT PRIMARY KEY DEFAULT ('dsb_' || lower(hex(randomblob(8)))),\n\n  tenant_id TEXT NOT NULL DEFAULT 'tenant_inneranimalmedia',\n  workspace_id TEXT NOT NULL DEFAULT 'ws_inneranimalmedia',\n  project_id TEXT,\n\n  title TEXT NOT NULL,\n  description TEXT,\n  original_prompt TEXT,\n\n  intent_json TEXT NOT NULL DEFAULT '{}',\n\n  cad_script TEXT,\n  cad_engine TEXT DEFAULT 'openscad',\n\n  sketch_json TEXT DEFAULT '{}',\n  preview_image_url TEXT,\n\n  generation_config_json TEXT DEFAULT '{}',\n\n  latest_asset_id TEXT,\n  latest_run_id TEXT,\n\n  status TEXT NOT NULL DEFAULT 'draft'\n    CHECK (status IN (\n      'draft',\n      'structured',\n      'generated',\n      'validated',\n      'exported',\n      'failed'\n    )),\n\n  quality_score REAL DEFAULT 0,\n  success_rate REAL DEFAULT 0,\n\n  tags TEXT DEFAULT '[]',\n  notes TEXT,\n\n  total_tokens INTEGER DEFAULT 0,\n  total_cost_usd REAL DEFAULT 0,\n  avg_latency_ms REAL DEFAULT 0,\n\n  created_at TEXT NOT NULL DEFAULT (datetime('now')),\n  updated_at TEXT NOT NULL DEFAULT (datetime('now'))\n, preview_svg_url TEXT);\nCREATE TABLE \"scene_snapshots\" (\n  id              TEXT PRIMARY KEY DEFAULT ('scene_' || lower(hex(randomblob(8)))),\n  workspace_id    TEXT NOT NULL,\n  user_id         TEXT NOT NULL,\n  tenant_id       TEXT NOT NULL DEFAULT 'tenant_sam_primeaux',\n  name            TEXT NOT NULL DEFAULT 'Untitled Scene',\n  project_type    TEXT NOT NULL DEFAULT 'SANDBOX',\n  entity_count    INTEGER NOT NULL DEFAULT 0,\n  r2_key          TEXT NOT NULL,\n  r2_bucket       TEXT NOT NULL DEFAULT 'inneranimalmedia',\n  public_url      TEXT,\n  thumbnail_r2_key TEXT,\n  thumbnail_url   TEXT,\n  tags            TEXT DEFAULT '[]',\n  description     TEXT,\n  is_autosave     INTEGER NOT NULL DEFAULT 0,\n  version         INTEGER NOT NULL DEFAULT 1,\n  created_at      INTEGER NOT NULL DEFAULT (unixepoch()),\n  updated_at      INTEGER NOT NULL DEFAULT (unixepoch())\n, project_id TEXT, glb_r2_key TEXT, style_preset TEXT, voxel_count INTEGER, cad_job_id TEXT);";
+const project=JSON.parse(fs.readFileSync(new URL('../fixtures/cad/courtyard-house.json',import.meta.url),'utf8'));
+test('existing D1 tables support scoped immutable revisions and optimistic concurrency',async t=>{
+ const sqlite=new DatabaseSync(':memory:');t.after(()=>sqlite.close());sqlite.exec(schema);
+ const db={prepare(sql){return {bind(...params){return {sql,params,async first(){return sqlite.prepare(sql).get(...params)||null;}};}};},
+ async batch(statements){sqlite.exec('BEGIN');try{const results=statements.map(s=>({meta:{changes:Number(sqlite.prepare(s.sql).run(...s.params).changes)}}));sqlite.exec('COMMIT');return results;}catch(e){sqlite.exec('ROLLBACK');throw e;}}};
+ const blobs=new Map(),objects={async put(k,v){blobs.set(k,v);},async get(k){return blobs.has(k)?{async text(){return blobs.get(k);}}:null;}};
+ const scope={account_id:'test-owner',workspace_id:'test-workspace',tenant_id:'test-tenant'};
+ const store=new D1ProjectStore({db,objects,bucket:'test-bucket',scope});
+ await store.save(project,0);
+ await store.save({...project,name:'Revision two'},1);
+ await assert.rejects(store.save(project,1),/revision_conflict/);
+ assert.equal(sqlite.prepare('SELECT count(*) n FROM scene_snapshots').get().n,2);
+ assert.equal((await store.read(project.id,1)).project.name,project.name);
+ assert.equal((await store.restore(project.id,1,2)).revision,3);
+ const other=new D1ProjectStore({db,objects,bucket:'test-bucket',scope:{...scope,account_id:'other'}});
+ await assert.rejects(other.read(project.id),/project_not_found/);
+ await assert.rejects(other.save(project,3),/revision_conflict/);
+ assert.equal((await store.read(project.id)).revision,3);
+});

package/test/integration/cad-project-native.test.mjs

@@ -0,0 +1,24 @@
+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 {localProjectRuntime} from '../../src/lib/cad/project-cli.js';
+const enabled=process.env.AGENTSAM_TEST_NATIVE_CAD==='1';
+test('courtyard real build inspect export render and restored revision rebuild',{skip:!enabled&&'Set AGENTSAM_TEST_NATIVE_CAD=1; enabled runs must find Blender'},async t=>{
+ const root=process.env.AGENTSAM_CAD_TEST_OUTPUT||fs.mkdtempSync(path.join(os.tmpdir(),'cad-house-native-'));
+ if(!process.env.AGENTSAM_CAD_TEST_OUTPUT)t.after(()=>fs.rmSync(root,{recursive:true,force:true}));
+ const p=JSON.parse(fs.readFileSync(new URL('../fixtures/cad/courtyard-house.json',import.meta.url),'utf8'));
+ p.id='courtyard-'+Date.now();
+ const run=localProjectRuntime(root),saved=await run.execute('design_project_save',{project:p,expected_revision:0});
+ const input={project_id:p.id,revision:saved.revision};
+ const build=await run.execute('design_model_build',input);assert.ok(build.artifact.size_bytes>0);
+ const inspection=await run.execute('design_model_inspect',input);assert.ok(inspection.ok);
+ const glb=await run.execute('design_model_export',{...input,format:'glb'});assert.equal(fs.readFileSync(glb.artifact.path).subarray(0,4).toString(),'glTF');
+ const png=await run.execute('design_model_render',input);assert.equal(fs.readFileSync(png.artifact.path).subarray(1,4).toString(),'PNG');
+ const edited=await run.execute('design_apply_operation',{project_id:p.id,expected_revision:1,operation:{type:'update_wall',wallId:'wall-0',updates:{height3D:132}}});
+ assert.equal(edited.revision,2);
+ const restored=await run.execute('design_project_restore',{project_id:p.id,revision:1,expected_revision:2});assert.equal(restored.project.walls[0].height3D,120);
+ await run.execute('design_model_build',{project_id:p.id,revision:3});
+ console.log(JSON.stringify({root,project_id:p.id,build:build.artifact,glb:glb.artifact,png:png.artifact,restored_revision:3}));
+});

package/test/integration/cad-project-workflow.test.mjs

@@ -0,0 +1,9 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {runProjectWorkflow} from '../../src/lib/cad/project-workflows.js';
+test('workflow halts on invalid validation and records no claimed effects',async()=>{
+ let calls=0;await assert.rejects(runProjectWorkflow({execute:async()=>{calls++;return {valid:false,errors:['bad wall']};}},'cad.house_baseline',{project:{}}),/project_invalid/);assert.equal(calls,1);
+});
+test('edit workflow refuses stale expected revision before edit',async()=>{
+ const calls=[];await assert.rejects(runProjectWorkflow({execute:async(name)=>{calls.push(name);return {revision:2,project:{id:'p'}};}},'cad.edit_preview',{project_id:'p',expected_revision:1,operation:{}}),/revision_conflict/);assert.deepEqual(calls,['design_project_get']);
+});

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

@@ -0,0 +1,82 @@
+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 {validateProject,applyProjectOperation} from '../../src/lib/cad/project-contract.js';
+import {FileProjectStore} from '../../src/lib/cad/project-store.js';
+import {createProjectRuntime} from '../../src/lib/cad/project-runtime.js';
+import {localProjectRuntime} from '../../src/lib/cad/project-cli.js';
+import {projectToBlenderRecipe} from '../../src/lib/cad/project-recipe.js';
+import {createCapabilityAdapter} from '../../src/agent/capability-adapter.js';
+const project=JSON.parse(fs.readFileSync(new URL('../fixtures/cad/courtyard-house.json',import.meta.url),'utf8'));
+test('invalid references and non-finite geometry fail before mutation',()=>{
+ const p=structuredClone(project);p.walls[0].x1=Infinity;assert.equal(validateProject(p).valid,false);
+ p.walls[0].x1=0;p.doors[0].wallId='missing';assert.equal(validateProject(p).valid,false);
+ assert.equal(validateProject({...p,walls:{}}).valid,false);
+});
+test('batch is atomic, absent targets fail, and host deletion cascades',()=>{
+ const before=JSON.stringify(project);
+ assert.throws(()=>applyProjectOperation(project,{type:'batch_operations',operations:[{type:'delete_wall',wallId:'wall-4'},{type:'update_wall',wallId:'absent',updates:{height3D:96}}]}),/element_not_found/);
+ assert.equal(JSON.stringify(project),before);
+ assert.equal(applyProjectOperation(project,{type:'delete_wall',wallId:'wall-4'}).doors.length,0);
+});
+test('save reopen restore and stale revision checks preserve immutable snapshots',async t=>{
+ const dir=fs.mkdtempSync(path.join(os.tmpdir(),'cad-project-'));t.after(()=>fs.rmSync(dir,{recursive:true,force:true}));
+ const store=new FileProjectStore(dir);
+ await store.save(project,0);
+ const next=applyProjectOperation(project,{type:'update_wall',wallId:'wall-0',updates:{height3D:132}});
+ await store.save(next,1);
+ await assert.rejects(store.save(project,1),/revision_conflict/);
+ const restored=await new FileProjectStore(dir).restore(project.id,1,2);
+ assert.equal(restored.revision,3);assert.equal(restored.project.walls[0].height3D,120);assert.equal((await store.read(project.id,2)).project.walls[0].height3D,132);
+});
+test('native recipe converts inches to metres and preserves a real door gap',()=>{
+ const recipe=projectToBlenderRecipe(project);
+ assert.equal(recipe.operations.find(o=>o.name==='wall-0:0').scale[0],864*0.0254);
+ const pieces=recipe.operations.filter(o=>o.name?.startsWith('wall-4:'));
+ assert.equal(pieces.length,3);
+ assert.throws(()=>projectToBlenderRecipe({...project,roofType:'gable'}),/roof_geometry_not_supported/);
+});
+test('agent and runtime share executable CAD handlers',async t=>{
+ const root=fs.mkdtempSync(path.join(os.tmpdir(),'cad-agent-'));t.after(()=>fs.rmSync(root,{recursive:true,force:true}));
+ const adapter=createCapabilityAdapter({projectRoot:root});
+ assert.ok(adapter.toolDescriptors().some(t=>t.name==='design_project_save'));
+ await adapter.invoke('design_project_save',{project,expected_revision:0});
+ const result=await adapter.invoke('design_apply_operation',{project_id:project.id,expected_revision:1,operation:{type:'update_wall',wallId:'wall-0',updates:{height3D:132}}});
+ assert.equal(result.result.revision,2);
+});
+
+
+test('CAD registry projects the app into tools workflows and CLI graph relationships',()=>{
+ const manifest=JSON.parse(fs.readFileSync(new URL('../../registry/cad-project/manifest.json',import.meta.url),'utf8'));
+ const migration=fs.readFileSync(new URL('../../registry/cad-project/migration.sql',import.meta.url),'utf8');
+ assert.equal(manifest.product.slug,'agentsam-cad-creator');
+ assert.deepEqual(manifest.product.capability_keys,['design.read','design.write','design.export']);
+ assert.equal(manifest.product.cli_commands[0].id,'agentsam:cad:project');
+ assert.equal(manifest.tools.length,9);
+ assert.equal(manifest.workflows.length,2);
+ assert.match(migration,/WHERE slug='agentsam-cad-creator'/);
+ assert.equal((migration.match(/'exposes_tool'/g)||[]).length,9);
+ assert.equal((migration.match(/'provides_workflow'/g)||[]).length,2);
+ assert.equal((migration.match(/'exposes_command'/g)||[]).length,1);
+ assert.match(migration,/'cli_command','agentsam:cad:project'/);
+ assert.match(migration,/ON CONFLICT\(id\) DO UPDATE SET tool_name=excluded\.tool_name/);
+ assert.doesNotMatch(migration,/DO UPDATE SET[^;]*is_active=excluded\.is_active/);
+ assert.doesNotMatch(migration,/DO UPDATE SET[^;]*lifecycle=excluded\.lifecycle/);
+
+});
+
+
+test('CAD validate requires project or project_id and model-facing CAD tools declare non-strict rich payloads',async()=>{
+ const root=fs.mkdtempSync(path.join(os.tmpdir(),'cad-validate-source-'));
+ const runtime=localProjectRuntime(root);
+ await assert.rejects(()=>runtime.execute('design_project_validate',{}),/argument_required:project_or_project_id/);
+ const adapter=createCapabilityAdapter({projectRoot:root});
+ const save=adapter.toolDescriptors().find(t=>t.name==='design_project_save');
+ const edit=adapter.toolDescriptors().find(t=>t.name==='design_apply_operation');
+ assert.equal(save.strict,false);
+ assert.equal(edit.strict,false);
+ assert.equal(save.input_schema.properties.project.additionalProperties,true);
+ assert.equal(edit.input_schema.properties.operation.additionalProperties,true);
+});

package/test/integration/cli-help.test.mjs

@@ -30,6 +30,10 @@ test('agentsam help is concise, topic-aware, and deterministic outside a TTY', (
   assert.match(all.stdout, /Build \/ inspect/);
   assert.match(all.stdout, /Create \/ extend/);
 
+  const allAlias = run('help', 'all');
+  assert.equal(allAlias.status, 0, allAlias.stderr);
+  assert.equal(allAlias.stdout, all.stdout);
+
   const flag = run('--help');
   assert.equal(flag.status, 0, flag.stderr);
   assert.match(flag.stdout, /agentsam help <topic>/);