Skip to content

3D engine that AI agents drive

8.4 KB
Raw Blame
import assert from 'node:assert/strict';
import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
import { tmpdir, constants, setPriority } from 'node:os';
import { join, resolve } from 'node:path';
import { createHash } from 'node:crypto';
import { spawnSync } from 'node:child_process';
import { Client } from '@modelcontextprotocol/client';
import { PatientStdioClientTransport } from './patient-stdio-transport.mjs';
import { createAgentCharacterFixture } from './agent-character-fixture.mjs';
import { createTexturedRigFixture } from './agent-asset-fixture.mjs';
import { assertToolListMatchesServer } from './mcp-tool-list.mjs';

setPriority(0, constants.priority.PRIORITY_BELOW_NORMAL);
const directory = await mkdtemp(join(tmpdir(), 'crucible-review-proof-'));
const assets = join(directory, 'assets');
await mkdir(assets);
const fixture = await createAgentCharacterFixture();
await writeFile(join(assets, 'pip.glb'), fixture.bytes);
fixture.recipe.assetId = createHash('sha256').update(fixture.bytes).digest('hex');
const clipFixture = await createTexturedRigFixture();
await writeFile(join(assets, 'clip-rig.glb'), clipFixture);
const clipAssetId = createHash('sha256').update(clipFixture).digest('hex');
const cli = resolve(process.argv[2] ?? 'bin/crucible-mcp.mjs');
const transport = new PatientStdioClientTransport({ command: process.execPath,
  args: [cli, '--backend', 'cpu', '--memory', '96', '--assets', assets], cwd: directory, stderr: 'pipe' });
let diagnostics = '';
transport.stderr.on('data', bytes => { diagnostics = (diagnostics + bytes).slice(-8192); });
const client = new Client({ name: 'crucible-review-proof', version: '1' });
async function call(name, argumentsValue) {
  const result = await client.callTool({ name, arguments: argumentsValue }, { timeout: 60000 });
  assert.equal(result.isError, undefined, result.content?.find(item => item.type === 'text')?.text);
  return result;
}
async function rejected(argumentsValue) {
  const result = await client.callTool({ name: 'scene_review', arguments: argumentsValue }, { timeout: 60000 });
  assert.equal(result.isError, true, 'Invalid review must fail rather than commit source changes');
}
function image(result) {
  const block = result.content.find(item => item.type === 'image');
  assert.equal(block.mimeType, 'image/png');
  return Buffer.from(block.data, 'base64');
}
function pixels(bytes, crop) {
  const decoded = spawnSync('ffmpeg', ['-hide_banner', '-loglevel', 'error', '-i', 'pipe:0',
    ...(crop ? ['-vf', crop] : []), '-frames:v', '1', '-f', 'rawvideo', '-pix_fmt', 'rgba', 'pipe:1'],
    { input: bytes, windowsHide: true, maxBuffer: 8 * 1024 * 1024 });
  assert.equal(decoded.status, 0, decoded.stderr.toString());
  return decoded.stdout;
}
try {
  await client.connect(transport);
  await assertToolListMatchesServer(client);
  const created = (await call('scene_create_asset', { recipe: fixture.recipe })).structuredContent;
  const sessionId = created.sessionId;
  const checkpoint = (await call('scene_checkpoint', { sessionId })).structuredContent;
  const canonical = (await call('scene_export_recipe', { sessionId })).structuredContent.recipe;
  const base = image(await call('scene_look', { sessionId, motionTime: null, width: 384, height: 384 }));
  const preview = image(await call('scene_look', { sessionId, motionTime: 1.5, width: 384, height: 384 }));
  assert.notDeepEqual(base, preview);
  const settings = { sessionId, expectedRevision: 0, width: 384, height: 384 };
  const single = await call('scene_review', { ...settings, shots: [{ label: 'One pose', motionTime: 1.5 }] });
  assert.equal(single.structuredContent.width, 384);
  assert.equal(single.structuredContent.height, 408);
  assert.deepEqual(pixels(image(single), 'crop=384:384:0:24'), pixels(preview));
  const maximum = await call('scene_review', { ...settings, shots: [
    { label: 'Start', motionTime: 0 }, { label: 'Middle', motionTime: 1.5 },
    { label: 'End', motionTime: 3 }, { label: 'Authored base' },
  ] });
  assert.equal(maximum.structuredContent.width, 768);
  assert.equal(maximum.structuredContent.height, 816);
  assert.deepEqual(pixels(image(maximum), 'crop=384:384:384:432'), pixels(base));

  const views = await call('scene_review', { ...settings, shots: [
    { label: 'Front', motionTime: 1.5, camera: { eye: [0, 2, 7], target: [0, 1.55, 0] } },
    { label: 'Side', motionTime: 1.5, camera: { eye: [7, 2, 0], target: [0, 1.55, 0] } },
    { label: 'Back', motionTime: 1.5, camera: { eye: [0, 2, -7], target: [0, 1.55, 0] } },
  ] });
  const grid = image(views);
  assert.ok(grid.length <= 1024 * 1024);
  await mkdir('artifacts', { recursive: true });
  await writeFile('artifacts/agent-review-views.png', grid);
  const poses = await call('scene_review', { ...settings,
    shots: [{ label: 'Motion at 1.5', motionTime: 1.5 }, { label: 'Authored base' }] });
  const poseGrid = image(poses);
  await writeFile('artifacts/agent-review-poses.png', poseGrid);
  assert.deepEqual(pixels(poseGrid, 'crop=384:384:384:24'), pixels(base), 'Omitted second shot must independently return the authored base');
  assert.notDeepEqual(pixels(poseGrid, 'crop=384:384:0:24'), pixels(base));
  assert.deepEqual(image(await call('scene_look', { sessionId, width: 384, height: 384 })), preview);
  assert.deepEqual((await call('scene_export_recipe', { sessionId })).structuredContent.recipe, canonical);
  for (const invalid of [
    { ...settings, expectedRevision: 1, shots: [{}] },
    { ...settings, shots: Array(5).fill({}) },
    { ...settings, shots: [{ file: 'outside.png' }] },
    { ...settings, shots: [{ motionTime: 0 }, { animation: { clip: 999, time: 0 } }] },
    { ...settings, shots: [{}, { camera: { eye: [0, 0, 0], target: [0, 0, 0] } }] },
  ]) {
    await rejected(invalid);
    assert.deepEqual(image(await call('scene_look', { sessionId, width: 384, height: 384 })), preview);
    assert.deepEqual((await call('scene_export_recipe', { sessionId })).structuredContent.recipe, canonical);
  }
  const inspected = (await call('scene_inspect', { sessionId })).structuredContent;
  assert.equal(inspected.revision, 0);
  await call('scene_apply', { sessionId, expectedRevision: 0,
    operations: [{ type: 'set-camera', eye: [0, 4, 7] }] });
  await call('scene_restore', { sessionId, expectedRevision: 1, checkpointId: checkpoint.checkpointId });
  assert.deepEqual(image(await call('scene_look', { sessionId, motionTime: 1.5, width: 384, height: 384 })), preview);
  await call('scene_dispose', { sessionId });
  const imported = (await call('scene_create_asset', { recipe: {
    format: 'crucible.asset', schemaVersion: 1, assetId: clipAssetId,
    camera: { eye: [1, 3, 7], target: [1, 3, 0], fov: 35, near: 0.1, far: 40 },
  } })).structuredContent;
  const clipSessionId = imported.sessionId;
  const clipBase = image(await call('scene_look', { sessionId: clipSessionId, width: 384, height: 384 }));
  await call('scene_apply', { sessionId: clipSessionId, expectedRevision: 0,
    operations: [{ type: 'set-animation', clip: 0, time: 1.1 }] });
  const clipPreview = image(await call('scene_look', { sessionId: clipSessionId, width: 384, height: 384 }));
  assert.notDeepEqual(clipPreview, clipBase);
  const clips = await call('scene_review', { sessionId: clipSessionId, expectedRevision: 1,
    width: 384, height: 384, shots: [
      { label: 'Clip at zero', animation: { clip: 0, time: 0 } },
      { label: 'Authored clip at 1.1' },
    ] });
  const clipGrid = image(clips);
  assert.deepEqual(pixels(clipGrid, 'crop=384:384:0:24'), pixels(clipBase));
  assert.deepEqual(pixels(clipGrid, 'crop=384:384:384:24'), pixels(clipPreview));
  assert.deepEqual(image(await call('scene_look', { sessionId: clipSessionId, width: 384, height: 384 })), clipPreview);
  await writeFile('artifacts/agent-review-clips.png', clipGrid);
  await call('scene_dispose', { sessionId: clipSessionId });
  const report = { cli, tools: 18, singleShotPixelsExact: true, maximumShotsPixelsExact: true, sourceRevisionUnchanged: true, previewPngExact: true,
    independentBasePixelsExact: true, checkpointRetained: true, invalidInputsPreserveSource: true,
    importedClipPixelsExact: true, views: views.structuredContent, poses: poses.structuredContent,
    clips: clips.structuredContent };
  await writeFile('artifacts/mcp-agent-review-proof.json', JSON.stringify(report, null, 2));
  console.log(JSON.stringify(report));
} finally {
  await client.close();
  assert.equal(diagnostics.replace('Crucible preview resources closed.\n', '').trim(), '');
}