@inneranimalmedia/agentsam-sdk 2.3.0 → 2.4.1

package/test/blender-cad.test.mjs

@@ -0,0 +1,146 @@
+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 {
+  BLENDER_ADAPTER_PATH,
+  blenderBuild,
+  blenderInspect,
+  blenderStatus,
+  createBlenderInvocation,
+  discoverBlender,
+  parseBlenderResult,
+  validateBlenderRecipe,
+} from '../src/lib/cad/index.js';
+
+function fixture(t) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-blender-test-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const binary = path.join(root, process.platform === 'win32' ? 'blender.exe' : 'blender');
+  fs.writeFileSync(binary, 'fake blender\n');
+  const blend = path.join(root, 'source.blend');
+  fs.writeFileSync(blend, 'blend fixture\n');
+  return { root, binary, blend };
+}
+
+function resultEnvelope(value) {
+  return { code: 0, stdout: `Blender startup noise\nAGENTSAM_RESULT=${JSON.stringify(value)}\n`, stderr: '' };
+}
+
+test('Blender adapter is packaged at the SDK-owned fixed path', () => {
+  assert.equal(path.basename(BLENDER_ADAPTER_PATH), 'adapter.py');
+  assert.ok(fs.existsSync(BLENDER_ADAPTER_PATH));
+});
+
+test('discoverBlender honors explicit binary before environment discovery', t => {
+  const { binary } = fixture(t);
+  assert.equal(discoverBlender({ blenderBin: binary, env: { AGENTSAM_BLENDER_BIN: '/wrong' } }), fs.realpathSync(binary));
+  assert.throws(() => discoverBlender({ blenderBin: path.join(path.dirname(binary), 'missing') }), /not found/);
+});
+
+test('Blender status uses argv execution and returns version without shell parsing', async t => {
+  const { binary } = fixture(t);
+  const calls = [];
+  const result = await blenderStatus({
+    blenderBin: binary,
+    runProcessImpl: async (command, args) => {
+      calls.push({ command, args });
+      return { code: 0, stdout: 'Blender 4.5.3 LTS\n', stderr: '' };
+    },
+  });
+  assert.equal(result.available, true);
+  assert.equal(result.version, 'Blender 4.5.3 LTS');
+  assert.deepEqual(calls, [{ command: fs.realpathSync(binary), args: ['--version'] }]);
+});
+
+test('typed Blender recipe rejects arbitrary or unknown operations', () => {
+  const valid = validateBlenderRecipe({
+    schema_version: 1,
+    operations: [
+      { op: 'add', primitive: 'cube', name: 'Body', size: 20 },
+      { op: 'bevel', object: 'Body', width: 1, segments: 3 },
+    ],
+  });
+  assert.equal(valid.operations.length, 2);
+  assert.throws(() => validateBlenderRecipe({ schema_version: 1, operations: [{ op: 'python', code: 'import bpy' }] }), /unsupported Blender recipe operation/);
+});
+
+test('Blender invocation is background + fixed adapter + typed request, never shell code', t => {
+  const { binary, blend, root } = fixture(t);
+  const requestPath = path.join(root, 'request.json');
+  const value = createBlenderInvocation({ operation: 'inspect', input: blend, requestPath, blenderBin: binary });
+  assert.equal(value.command, binary);
+  assert.deepEqual(value.args.slice(0, 2), ['--background', blend]);
+  assert.ok(value.args.includes('--python'));
+  assert.ok(value.args.includes(BLENDER_ADAPTER_PATH));
+  assert.deepEqual(value.args.slice(-4), ['--operation', 'inspect', '--request', requestPath]);
+});
+
+test('parseBlenderResult ignores Blender logs and reads the machine envelope', () => {
+  assert.deepEqual(parseBlenderResult('noise\nAGENTSAM_RESULT={"ok":true,"value":7}\n'), { ok: true, value: 7 });
+  assert.throws(() => parseBlenderResult('noise only'), /did not return/);
+});
+
+test('blenderInspect returns source hash and scene evidence without writing source', async t => {
+  const { binary, blend } = fixture(t);
+  const before = fs.readFileSync(blend, 'utf8');
+  const result = await blenderInspect({
+    input: blend,
+    blenderBin: binary,
+    runProcessImpl: async () => resultEnvelope({
+      ok: true,
+      blender_version: '4.5.3',
+      scene: { active: 'Scene', objects: [{ name: 'Body', type: 'MESH' }] },
+      warnings: [],
+    }),
+  });
+  assert.equal(result.capability, 'blender.inspect');
+  assert.equal(result.scene.objects[0].name, 'Body');
+  assert.match(result.input.sha256, /^[a-f0-9]{64}$/);
+  assert.equal(fs.readFileSync(blend, 'utf8'), before);
+});
+
+test('blenderBuild executes a bounded recipe and produces a hashed .blend artifact', async t => {
+  const { binary, root } = fixture(t);
+  const output = path.join(root, 'built.blend');
+  const recipe = {
+    schema_version: 1,
+    units: { system: 'METRIC', scale_length: 0.001, length_unit: 'MILLIMETERS' },
+    operations: [
+      { op: 'clear_scene' },
+      { op: 'add', primitive: 'cube', name: 'Body', size: 20 },
+      { op: 'add', primitive: 'cylinder', name: 'Hole', radius: 3, depth: 30 },
+      { op: 'boolean', object: 'Body', with: 'Hole', operation: 'DIFFERENCE', delete_operand: true },
+    ],
+  };
+  let seenRequest;
+  const result = await blenderBuild({
+    output,
+    recipe,
+    blenderBin: binary,
+    runProcessImpl: async (_command, args) => {
+      const requestPath = args[args.indexOf('--request') + 1];
+      seenRequest = JSON.parse(fs.readFileSync(requestPath, 'utf8'));
+      fs.writeFileSync(seenRequest.output, 'generated blend artifact\n');
+      return resultEnvelope({ ok: true, blender_version: '4.5.3', operations_applied: recipe.operations.length, objects: ['Body'], warnings: [] });
+    },
+  });
+  assert.equal(seenRequest.recipe.operations[3].operation, 'DIFFERENCE');
+  assert.equal(result.capability, 'blender.build');
+  assert.equal(result.artifact.path, output);
+  assert.equal(result.artifact.format, 'blend');
+  assert.match(result.artifact.sha256, /^[a-f0-9]{64}$/);
+  assert.deepEqual(result.objects, ['Body']);
+});
+
+test('Blender build refuses to overwrite an input source .blend', async t => {
+  const { binary, blend } = fixture(t);
+  await assert.rejects(() => blenderBuild({
+    input: blend,
+    output: blend,
+    blenderBin: binary,
+    recipe: { schema_version: 1, operations: [{ op: 'clear_scene' }] },
+    runProcessImpl: async () => { throw new Error('runner should not execute'); },
+  }), /never overwrite/);
+});

package/test/open-url.test.mjs

@@ -0,0 +1,64 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { PassThrough } from 'node:stream';
+import { browserCommand, promptToOpenUrl } from '../src/lib/open-url.js';
+
+test('browserCommand uses argv-safe platform launchers', () => {
+  assert.deepEqual(browserCommand('https://inneranimalmedia.com/auth', 'darwin'), {
+    command: 'open',
+    args: ['https://inneranimalmedia.com/auth'],
+  });
+  assert.deepEqual(browserCommand('https://inneranimalmedia.com/auth', 'linux'), {
+    command: 'xdg-open',
+    args: ['https://inneranimalmedia.com/auth'],
+  });
+  assert.deepEqual(browserCommand('https://inneranimalmedia.com/auth', 'win32'), {
+    command: 'cmd',
+    args: ['/c', 'start', '', 'https://inneranimalmedia.com/auth'],
+  });
+});
+
+test('browserCommand rejects non-http protocols', () => {
+  assert.throws(() => browserCommand('file:///tmp/example', 'darwin'), /Unsupported URL protocol/);
+  assert.throws(() => browserCommand('javascript:alert(1)', 'darwin'), /Unsupported URL protocol/);
+});
+
+test('promptToOpenUrl stays non-interactive when stdin is not a TTY', async () => {
+  const input = new PassThrough();
+  const output = new PassThrough();
+  let text = '';
+  output.on('data', chunk => { text += chunk.toString(); });
+  let opened = false;
+  const result = await promptToOpenUrl('https://www.blender.org/download/', {
+    input,
+    output,
+    openImpl: () => { opened = true; },
+  });
+  assert.equal(result.interactive, false);
+  assert.equal(result.opened, false);
+  assert.equal(opened, false);
+  assert.match(text, /https:\/\/www\.blender\.org\/download\//);
+  assert.match(text, /Open the URL above in a browser/);
+});
+
+test('promptToOpenUrl waits for Enter before opening in a TTY', async () => {
+  const input = new PassThrough();
+  const output = new PassThrough();
+  input.isTTY = true;
+  output.isTTY = true;
+  let text = '';
+  output.on('data', chunk => { text += chunk.toString(); });
+  let openedUrl = null;
+  const pending = promptToOpenUrl('https://inneranimalmedia.com/dashboard', {
+    input,
+    output,
+    openImpl: url => { openedUrl = url; },
+  });
+  input.write('\n');
+  const result = await pending;
+  assert.equal(result.interactive, true);
+  assert.equal(result.opened, true);
+  assert.equal(openedUrl, 'https://inneranimalmedia.com/dashboard');
+  assert.match(text, /Press ENTER to open/);
+  assert.match(text, /Browser opened/);
+});