@inneranimalmedia/agentsam-sdk 2.4.0 → 2.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inneranimalmedia/agentsam-sdk",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "Portable AgentSam SDK and CLI kits for local scaffolding, repository intelligence, incremental indexing, identity adapters, and verified dependency maintenance.",
   "type": "module",
   "main": "./src/index.js",
@@ -128,7 +128,6 @@
   },
   "homepage": "https://github.com/SamPrimeaux/agentsam-sdk#readme",
   "allowScripts": {
-    "node-pty@1.0.0": true,
     "node-pty@1.1.0": true
   },
   "devDependencies": {

package/packages/identity/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inneranimalmedia/agentsam-sdk-identity",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "private": true,
   "type": "module",
   "description": "Identity module for @inneranimalmedia/agentsam-sdk (workspace — publish via root SDK)",

package/src/commands/cad.js

@@ -7,6 +7,9 @@ import {
   blenderRenderPreview,
   blenderStatus,
 } from '../lib/cad/index.js';
+import { promptToOpenUrl } from '../lib/open-url.js';
+
+const BLENDER_DOWNLOAD_URL = 'https://www.blender.org/download/';
 
 function usage() {
   return `AgentSam programmatic CAD
@@ -24,6 +27,7 @@ Shared options:
   --cwd <path>          Resolve input/output paths from another directory.
   --json                Machine-readable output.
 
+If Blender is missing, AgentSam explains what is required and can open the official Blender download page.
 The build command consumes a typed recipe; it never evaluates arbitrary Python.`;
 }
 
@@ -49,20 +53,53 @@ function parseArgs(argv) {
   return opts;
 }
 
+function withBlenderInstallGuidance(value) {
+  if (value?.available !== false) return value;
+  return {
+    ...value,
+    install: {
+      required: true,
+      app: 'Blender',
+      url: BLENDER_DOWNLOAD_URL,
+      message: 'Install Blender, then rerun this command. AgentSam will discover standard installs automatically.',
+      alternatives: [
+        'Pass --blender-bin <path> for a custom Blender executable.',
+        'Set AGENTSAM_BLENDER_BIN for a persistent custom executable path.',
+      ],
+    },
+  };
+}
+
 function output(value, json) {
   if (json) {
     console.log(JSON.stringify(value));
     return;
   }
   if (value.capability === 'blender.status') {
-    console.log(value.available
-      ? `Blender available: ${value.version || 'unknown version'}\n${value.binary}`
-      : `Blender unavailable${value.error ? `: ${value.error}` : ''}`);
+    if (value.available) {
+      console.log(`Blender available: ${value.version || 'unknown version'}\n${value.binary}`);
+    } else {
+      console.log(`Blender unavailable${value.error ? `: ${value.error}` : ''}`);
+      if (value.install?.message) console.log(value.install.message);
+      if (value.install?.url) console.log(`Download: ${value.install.url}`);
+    }
     return;
   }
   console.log(JSON.stringify(value, null, 2));
 }
 
+async function presentMissingBlender(value, json) {
+  const guided = withBlenderInstallGuidance(value);
+  output(guided, json);
+  if (!json) {
+    await promptToOpenUrl(BLENDER_DOWNLOAD_URL, {
+      heading: 'Blender is required for AgentSam programmatic CAD:',
+      prompt: 'Press ENTER to open the official Blender download page.',
+    });
+  }
+  return guided;
+}
+
 function required(value, message) {
   if (!value) throw new Error(message);
   return value;
@@ -90,10 +127,23 @@ export async function runCad(argv) {
     cwd,
   };
 
-  let result;
   if (action === 'status') {
-    result = await blenderStatus(shared);
-  } else if (action === 'inspect') {
+    const status = withBlenderInstallGuidance(await blenderStatus(shared));
+    output(status, opts.json);
+    if (!status.available && !opts.json) {
+      await promptToOpenUrl(BLENDER_DOWNLOAD_URL, {
+        heading: 'Install Blender to enable AgentSam CAD:',
+        prompt: 'Press ENTER to open the official Blender download page.',
+      });
+    }
+    return status;
+  }
+
+  const availability = await blenderStatus(shared);
+  if (!availability.available) return presentMissingBlender(availability, opts.json);
+
+  let result;
+  if (action === 'inspect') {
     result = await blenderInspect({ ...shared, input: required(opts.positional[0], 'inspect requires <model.blend>') });
   } else if (action === 'build') {
     const recipeFile = path.resolve(cwd, required(opts.positional[0], 'build requires <recipe.json>'));

package/src/lib/auth.js

@@ -1,28 +1,15 @@
 /**
  * Browser OAuth for SDK init — one click IAM login + Cloudflare connect.
  */
-import http from 'http';
-import { randomBytes } from 'crypto';
+import http from 'node:http';
+import { randomBytes } from 'node:crypto';
 import { postJson } from './core-client.js';
+import { promptToOpenUrl } from './open-url.js';
 
 function randomState() {
   return randomBytes(16).toString('hex');
 }
 
-function openBrowser(url) {
-  const start =
-    process.platform === 'darwin'
-      ? ['open', url]
-      : process.platform === 'win32'
-        ? ['cmd', '/c', 'start', '', url]
-        : ['xdg-open', url];
-  import('child_process').then(({ spawn }) => {
-    spawn(start[0], start.slice(1), { stdio: 'ignore', detached: true }).unref();
-  }).catch(() => {
-    console.log(`\n  Open in browser:\n  ${url}\n`);
-  });
-}
-
 /**
  * @returns {Promise<{ access_token: string, user_id: string, workspace_id: string, tenant_id: string }>}
  */
@@ -36,6 +23,8 @@ export async function authenticateViaBrowser() {
     state,
   });
 
+  if (!authUrl) throw new Error('IAM auth did not return an authorization URL');
+
   const codePromise = new Promise((resolve, reject) => {
     const server = http.createServer((req, res) => {
       try {
@@ -55,7 +44,7 @@ export async function authenticateViaBrowser() {
           return;
         }
         res.writeHead(200, { 'Content-Type': 'text/html' });
-        res.end('<html><body style="font-family:system-ui"><h1>Agent Sam</h1><p>You can close this tab.</p></body></html>');
+        res.end('<html><body style="font-family:system-ui"><h1>Agent Sam</h1><p>Authentication complete. You can close this tab and return to your terminal.</p></body></html>');
         resolve(code);
         server.close();
       } catch (e) {
@@ -67,8 +56,10 @@ export async function authenticateViaBrowser() {
     server.listen(port, '127.0.0.1');
   });
 
-  console.log('\n  Opening browser for IAM sign-in + Cloudflare connect…\n');
-  openBrowser(authUrl);
+  await promptToOpenUrl(authUrl, {
+    heading: 'Authenticate your InnerAnimalMedia account at:',
+    prompt: 'Press ENTER to open InnerAnimalMedia sign-in in your browser.',
+  });
 
   const code = await codePromise;
   const session = await postJson('/api/sdk/auth/exchange', { code, state });

package/src/lib/open-url.js

@@ -0,0 +1,66 @@
+import readline from 'node:readline';
+import { spawn } from 'node:child_process';
+
+function normalizeHttpUrl(value) {
+  const raw = String(value || '').trim();
+  if (!raw) throw new Error('URL is required');
+  let parsed;
+  try { parsed = new URL(raw); }
+  catch { throw new Error(`Invalid URL: ${raw}`); }
+  if (!['http:', 'https:'].includes(parsed.protocol)) {
+    throw new Error(`Unsupported URL protocol: ${parsed.protocol}`);
+  }
+  return parsed.toString();
+}
+
+export function browserCommand(url, platform = process.platform) {
+  const normalized = normalizeHttpUrl(url);
+  if (platform === 'darwin') return { command: 'open', args: [normalized] };
+  if (platform === 'win32') return { command: 'cmd', args: ['/c', 'start', '', normalized] };
+  return { command: 'xdg-open', args: [normalized] };
+}
+
+export function openExternalUrl(url, {
+  platform = process.platform,
+  spawnImpl = spawn,
+} = {}) {
+  const invocation = browserCommand(url, platform);
+  const child = spawnImpl(invocation.command, invocation.args, {
+    stdio: 'ignore',
+    detached: true,
+  });
+  child.unref?.();
+  return invocation;
+}
+
+export async function promptToOpenUrl(url, {
+  heading = 'Open in your browser:',
+  prompt = 'Press ENTER to open in the browser, or copy the URL above.',
+  input = process.stdin,
+  output = process.stdout,
+  openImpl = openExternalUrl,
+} = {}) {
+  const normalized = normalizeHttpUrl(url);
+  output.write(`\n${heading}\n${normalized}\n`);
+
+  if (!input?.isTTY || !output?.isTTY) {
+    output.write('Open the URL above in a browser to continue.\n\n');
+    return { url: normalized, opened: false, interactive: false };
+  }
+
+  const rl = readline.createInterface({ input, output });
+  try {
+    await new Promise(resolve => rl.question(`\n${prompt}\n`, resolve));
+  } finally {
+    rl.close();
+  }
+
+  try {
+    openImpl(normalized);
+    output.write('\nBrowser opened. Complete the step there, then return here.\n\n');
+    return { url: normalized, opened: true, interactive: true };
+  } catch (error) {
+    output.write(`\nCould not open the browser automatically: ${error.message}\nOpen the URL above manually.\n\n`);
+    return { url: normalized, opened: false, interactive: true, error: error.message };
+  }
+}

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/);
+});