@inneranimalmedia/agentsam-sdk 2.6.7 → 2.6.9

package/test/models.test.mjs

@@ -1,309 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import test from 'node:test';
-import { collectModelsStatus, renderModelsStatus } from '../src/commands/models.js';
-
-function response(body, status = 200) {
-  return { ok: status >= 200 && status < 300, status, async json() { return body; } };
-}
-
-function tempHome(t) {
-  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-model-home-'));
-  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
-  return home;
-}
-
-test('model inventory reports configured API providers without exposing credentials', async t => {
-  const home = tempHome(t);
-  const status = await collectModelsStatus({
-    home,
-    discoverRemote: false,
-    env: {
-      OPENAI_API_KEY: 'secret-openai', GEMINI_API_KEY: '', XAI_API_KEY: 'secret-xai', ANTHROPIC_API_KEY: 'secret-anthropic', CLOUDFLARE_API_TOKEN: 'secret-cf', CLOUDFLARE_ACCOUNT_ID: '33333333333333333333333333333333',
-      OLLAMA_BASE_URL: 'http://127.0.0.1:11434', OLLAMA_MODEL: 'qwen:test', OLLAMA_EMBED_MODEL: 'embed:test',
-    },
-    fetchImpl: async () => response({ models: [{ name: 'qwen:test' }, { name: 'embed:test' }] }),
-  });
-  assert.equal(status.providers.find((row) => row.id === 'openai').configured, true);
-  assert.equal(status.providers.find((row) => row.id === 'gemini').configured, false);
-  assert.equal(status.providers.find((row) => row.id === 'grok').configured, true);
-  assert.equal(status.providers.find((row) => row.id === 'anthropic').configured, true);
-  assert.equal(status.providers.find((row) => row.id === 'cloudflare').configured, true);
-  assert.equal(status.local.online, true);
-  assert.deepEqual(status.local.models.map((row) => row.name), ['qwen:test', 'embed:test']);
-  const rendered = renderModelsStatus(status);
-  assert.match(rendered, /OpenAI/);
-  assert.match(rendered, /qwen:test/);
-  assert.doesNotMatch(rendered, /secret-openai|secret-xai|secret-anthropic|secret-cf/);
-});
-
-test('static/reference metadata never invents hosted model availability', async t => {
-  const home = tempHome(t);
-  const status = await collectModelsStatus({
-    home,
-    env: { OPENAI_API_KEY: 'secret-openai', OLLAMA_BASE_URL: 'http://127.0.0.1:11434' },
-    fetchImpl: async () => response({ models: [] }),
-    providerFetchImpl: async () => response({ data: [{ id: 'some-other-model' }] }),
-  });
-
-  assert.deepEqual(status.availableModels.map((row) => row.provider_model_id), ['some-other-model']);
-  const referenceOnly = status.catalogModels.find((row) => row.provider_model_id === 'gpt-6-astra');
-  assert.equal(referenceOnly?.availability, 'unverified');
-  assert.equal(referenceOnly?.availability_source, 'sdk_reference');
-});
-
-test('exact hosted model availability is verified against the provider inventory', async t => {
-  const home = tempHome(t);
-  const status = await collectModelsStatus({
-    home,
-    env: { OPENAI_API_KEY: 'secret-openai', OLLAMA_BASE_URL: 'http://127.0.0.1:11434' },
-    fetchImpl: async () => response({ models: [] }),
-    providerFetchImpl: async () => response({ data: [{ id: 'gpt-6-astra' }, { id: 'some-other-model' }] }),
-  });
-  assert.equal(status.discovery.openai.ok, true);
-  assert.equal(status.discovery.openai.returnedModelCount, 2);
-  assert.deepEqual(status.availableModels.map((row) => row.provider_model_id), ['gpt-6-astra', 'some-other-model']);
-  assert.equal(status.availableModels[0].availability_source, 'provider_api');
-  assert.equal(status.availableModels[0].context_window_source, 'sdk_reference');
-});
-
-
-
-
-test('Gemini and xAI discovery keep per-key limits from provider metadata', async t => {
-  const home = tempHome(t);
-  const seen = [];
-  const status = await collectModelsStatus({
-    home,
-    env: {
-      GEMINI_API_KEY: 'gem-key',
-      XAI_API_KEY: 'xai-key',
-      OLLAMA_BASE_URL: 'http://127.0.0.1:11434',
-    },
-    fetchImpl: async () => response({ models: [] }),
-    providerFetchImpl: async (url, options) => {
-      seen.push(url);
-      if (url.includes('generativelanguage.googleapis.com')) {
-        return response({ models: [{
-          name: 'models/gemini-test',
-          baseModelId: 'gemini-test',
-          displayName: 'Gemini Test',
-          inputTokenLimit: 123456,
-          outputTokenLimit: 8192,
-          supportedGenerationMethods: ['generateContent'],
-          thinking: true,
-        }] });
-      }
-      if (url.includes('api.x.ai')) {
-        return response({ data: [{
-          id: 'grok-test',
-          context_length: 256000,
-          prompt_text_token_price: 1000,
-          cached_prompt_text_token_price: 500,
-          completion_text_token_price: 4000,
-        }] });
-      }
-      throw new Error('unexpected URL ' + url);
-    },
-  });
-
-  const gemini = status.providerModels.gemini[0];
-  assert.equal(gemini.provider_model_id, 'gemini-test');
-  assert.equal(gemini.context_window, 123456);
-  assert.equal(gemini.context_window_source, 'provider_api');
-  assert.deepEqual(gemini.reasoning_efforts, ['auto', 'low', 'medium', 'high']);
-
-  const grok = status.providerModels.grok[0];
-  assert.equal(grok.provider_model_id, 'grok-test');
-  assert.equal(grok.context_window, 256000);
-  assert.equal(grok.pricing.input, 1);
-  assert.equal(grok.pricing.output, 4);
-  assert.equal(seen.some((url) => url.includes('generativelanguage.googleapis.com')), true);
-  assert.equal(seen.some((url) => url.includes('api.x.ai')), true);
-});
-
-
-test('Cloudflare discovery is scoped to the loaded account and surfaces text-generation + embeddings', async t => {
-  const seen = [];
-  const home = tempHome(t);
-  const status = await collectModelsStatus({
-    home,
-    curateWorkersAi: false,
-    env: { CLOUDFLARE_API_TOKEN: 'secret-cf', CLOUDFLARE_ACCOUNT_ID: '44444444444444444444444444444444', OLLAMA_BASE_URL: 'http://127.0.0.1:11434' },
-    fetchImpl: async () => response({ models: [] }),
-    providerFetchImpl: async (url, options) => {
-      seen.push({ url, auth: options.headers.authorization });
-      return response({ success: true, result: [
-        { name: '@cf/qwen/code', task: { name: 'Text Generation' }, description: 'coding' },
-        { name: '@cf/baai/embed', task: { name: 'Text Embeddings' }, description: 'embeddings' },
-      ] });
-    },
-  });
-  assert.equal(seen.length, 1);
-  assert.match(seen[0].url, /accounts\/44444444444444444444444444444444\/ai\/models\/search$/);
-  assert.equal(status.discovery.cloudflare.ok, true);
-  assert.equal(status.discovery.cloudflare.returnedModelCount, 2);
-  assert.deepEqual(
-    status.providerModels.cloudflare.map((row) => row.provider_model_id).sort(),
-    ['@cf/baai/embed', '@cf/qwen/code'],
-  );
-  const embed = status.providerModels.cloudflare.find((row) => row.provider_model_id === '@cf/baai/embed');
-  const qwen = status.providerModels.cloudflare.find((row) => row.provider_model_id === '@cf/qwen/code');
-  assert.equal(qwen.availability_source, 'provider_api');
-  assert.equal(qwen.context_window_source, 'unknown');
-  const rendered = renderModelsStatus(status);
-  assert.match(rendered, /@cf\/qwen\/code/);
-  assert.match(rendered, /@cf\/baai\/embed/);
-  assert.doesNotMatch(rendered, /secret-cf/);
-});
-
-test('Cursor participates in machine inventory when CURSOR_API_KEY is configured', async t => {
-  const home = tempHome(t);
-  const seen = [];
-  const status = await collectModelsStatus({
-    home,
-    env: {
-      CURSOR_API_KEY: 'cursor-secret-key',
-      OLLAMA_BASE_URL: 'http://127.0.0.1:11434',
-    },
-    fetchImpl: async () => response({ models: [] }),
-    providerFetchImpl: async (url, options) => {
-      seen.push({ url, auth: options?.headers?.authorization });
-      if (String(url).includes('api.cursor.com')) {
-        return response({
-          items: [
-            { id: 'composer-2.5', displayName: 'Composer 2.5', parameters: [] },
-            { id: 'gpt-5.6-sol', displayName: 'GPT-5.6 Sol', parameters: [{ id: 'reasoning', values: [{ value: 'high' }] }] },
-          ],
-        });
-      }
-      throw new Error('unexpected URL ' + url);
-    },
-  });
-
-  const cursor = status.providers.find((row) => row.id === 'cursor');
-  assert.equal(cursor?.configured, true);
-  assert.equal(status.discovery.cursor.ok, true);
-  assert.equal(status.discovery.cursor.returnedModelCount, 2);
-  assert.equal(seen.length, 1);
-  assert.match(seen[0].url, /api\.cursor\.com\/v1\/models/);
-  assert.match(seen[0].auth, /Bearer cursor-secret-key/);
-  assert.deepEqual(
-    status.availableModels.filter((row) => row.provider === 'cursor').map((row) => row.provider_model_id),
-    ['composer-2.5', 'gpt-5.6-sol'],
-  );
-  const rendered = renderModelsStatus(status);
-  assert.match(rendered, /Cursor/);
-  assert.match(rendered, /composer-2\.5/);
-  assert.doesNotMatch(rendered, /cursor-secret-key/);
-});
-
-test('missing Cursor credential skips discovery and does not fall back to another provider', async t => {
-  const home = tempHome(t);
-  const seen = [];
-  const status = await collectModelsStatus({
-    home,
-    env: {
-      OPENAI_API_KEY: 'secret-openai',
-      OLLAMA_BASE_URL: 'http://127.0.0.1:11434',
-    },
-    fetchImpl: async () => response({ models: [] }),
-    providerFetchImpl: async (url) => {
-      seen.push(url);
-      if (String(url).includes('api.openai.com')) return response({ data: [{ id: 'gpt-test' }] });
-      if (String(url).includes('api.cursor.com')) throw new Error('cursor must not be called');
-      return response({ data: [] });
-    },
-  });
-  assert.equal(status.providers.find((row) => row.id === 'cursor')?.configured, false);
-  assert.equal(status.discovery.cursor.attempted, false);
-  assert.equal(seen.some((url) => String(url).includes('api.cursor.com')), false);
-  assert.equal(status.availableModels.some((row) => row.provider === 'cursor'), false);
-  assert.equal(status.availableModels.some((row) => row.provider === 'openai'), true);
-});
-
-test('Cursor discovery failure stays attached to Cursor and does not invent OpenAI models', async t => {
-  const home = tempHome(t);
-  const status = await collectModelsStatus({
-    home,
-    env: {
-      CURSOR_API_KEY: 'bad-cursor-key',
-      OLLAMA_BASE_URL: 'http://127.0.0.1:11434',
-    },
-    fetchImpl: async () => response({ models: [] }),
-    providerFetchImpl: async (url) => {
-      if (String(url).includes('api.cursor.com')) {
-        return { ok: false, status: 401, async json() { return { error: 'unauthorized' }; } };
-      }
-      throw new Error('unexpected URL ' + url);
-    },
-  });
-  assert.equal(status.providers.find((row) => row.id === 'cursor')?.configured, true);
-  assert.equal(status.discovery.cursor.ok, false);
-  assert.ok(status.discovery.cursor.error);
-  assert.equal((status.providerModels.cursor || []).length, 0);
-  assert.equal(status.availableModels.some((row) => row.provider === 'openai'), false);
-});
-
-test('Workers AI curated allowlist intersects live Cloudflare discovery', async t => {
-  const home = tempHome(t);
-  const status = await collectModelsStatus({
-    home,
-    curateWorkersAi: true,
-    env: { CLOUDFLARE_API_TOKEN: 'secret-cf', CLOUDFLARE_ACCOUNT_ID: '44444444444444444444444444444444', OLLAMA_BASE_URL: 'http://127.0.0.1:11434' },
-    fetchImpl: async () => response({ models: [] }),
-    providerFetchImpl: async () => response({
-      success: true,
-      result: [
-        { name: '@cf/qwen/qwen2.5-coder-32b-instruct', task: { name: 'Text Generation' } },
-        { name: '@cf/meta/llama-3.2-1b-instruct', task: { name: 'Text Generation' } },
-        { name: '@cf/openai/gpt-oss-120b', task: { name: 'Text Generation' } },
-        { name: '@cf/baai/bge-base-en-v1.5', task: { name: 'Text Embeddings' } },
-      ],
-    }),
-  });
-  // Chat allowlist applies to Text Generation; Text Embeddings always pass (Vectorize lane).
-  assert.deepEqual(
-    status.providerModels.cloudflare.map((row) => row.provider_model_id).sort(),
-    ['@cf/baai/bge-base-en-v1.5', '@cf/openai/gpt-oss-120b', '@cf/qwen/qwen2.5-coder-32b-instruct'],
-  );
-  assert.equal(status.discovery.cloudflare.curation, 'agentsam_workers_ai_allowlist');
-});
-
-test('studio vault credential plane never reads machine env when resolver is injected', async t => {
-  const home = tempHome(t);
-  const status = await collectModelsStatus({
-    home,
-    credentialPlane: 'studio_vault',
-    includeLocal: false,
-    env: { OPENAI_API_KEY: 'machine-must-not-be-used', CURSOR_API_KEY: 'machine-cursor' },
-    resolveCredential: async (providerId) => {
-      if (providerId === 'gemini') {
-        return { configured: true, value: 'vault-gemini', source: 'user_vault', env: 'GEMINI_API_KEY' };
-      }
-      return { configured: false, value: '', source: null, error: null };
-    },
-    fetchImpl: async () => response({ models: [] }),
-    providerFetchImpl: async (url) => {
-      if (String(url).includes('generativelanguage.googleapis.com') && String(url).includes('vault-gemini')) {
-        return response({
-          models: [{
-            name: 'models/gemini-vault',
-            baseModelId: 'gemini-vault',
-            displayName: 'Vault Gemini',
-            inputTokenLimit: 1000,
-            supportedGenerationMethods: ['generateContent'],
-          }],
-        });
-      }
-      throw new Error('machine providers must not be discovered: ' + url);
-    },
-  });
-  assert.equal(status.credential_plane, 'studio_vault');
-  assert.equal(status.providers.find((row) => row.id === 'openai')?.configured, false);
-  assert.equal(status.providers.find((row) => row.id === 'gemini')?.configured, true);
-  assert.equal(status.providers.find((row) => row.id === 'gemini')?.source, 'user_vault');
-  assert.deepEqual(status.availableModels.map((row) => row.provider_model_id), ['gemini-vault']);
-});

package/test/npm10-lock.test.mjs

@@ -1,29 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import { describe, it } from 'node:test';
-import { spawnSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const lockPath = path.join(root, 'apps/local-studio/package-lock.json');
-
-describe('local-studio npm 10 lockfile', () => {
-  it('pins lru-cache@11.5.2 so Cloudflare npm ci can resolve it', () => {
-    const lock = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
-    assert.equal(lock.lockfileVersion, 3);
-    const pkgs = lock.packages || {};
-    const hits = Object.entries(pkgs).filter(([key, meta]) => key.includes('lru-cache') && meta.version === '11.5.2');
-    assert.ok(hits.length >= 1, 'Missing: lru-cache@11.5.2 from lock file');
-    const [, meta] = hits[0];
-    assert.match(meta.resolved || '', /lru-cache-11\.5\.2\.tgz/);
-    assert.ok(meta.integrity);
-  });
-
-  it('verify-npm10-lock script exits 0 against the current lock', () => {
-    const script = path.join(root, 'apps/local-studio/scripts/verify-npm10-lock.mjs');
-    const r = spawnSync(process.execPath, [script], { encoding: 'utf8' });
-    assert.equal(r.status, 0, r.stderr || r.stdout);
-    assert.match(r.stdout, /lru-cache@11\.5\.2/);
-  });
-});

package/test/ollama.test.mjs

@@ -1,137 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import test from 'node:test';
-import {
-  OLLAMA_DEFAULTS,
-  ollamaInstallPlan,
-  parseOllamaArgs,
-  probeOllama,
-  probeOllamaModel,
-  resolveOllamaConfig,
-  updateProjectOllamaConfig,
-  upsertOllamaEnvFile,
-} from '../src/commands/ollama.js';
-import { createProjectManifest } from '../src/lib/project-config.js';
-
-test('Ollama defaults are local-only and match the SDK local-dev contract', () => {
-  assert.deepEqual(OLLAMA_DEFAULTS, {
-    baseUrl: 'http://127.0.0.1:11434',
-    model: 'qwen2.5-coder',
-    embedModel: 'mxbai-embed-large',
-  });
-  assert.deepEqual(resolveOllamaConfig({}, {}), OLLAMA_DEFAULTS);
-});
-
-test('Ollama endpoints normalize host-only values and honor AgentSam precedence', () => {
-  assert.equal(resolveOllamaConfig({}, { OLLAMA_HOST: '0.0.0.0:11434' }).baseUrl, 'http://127.0.0.1:11434');
-  assert.equal(resolveOllamaConfig({}, { OLLAMA_HOST: '127.0.0.1:11434' }).baseUrl, 'http://127.0.0.1:11434');
-  assert.equal(resolveOllamaConfig({}, { OLLAMA_HOST: 'localhost:11434' }).baseUrl, 'http://localhost:11434');
-  assert.equal(resolveOllamaConfig({}, { OLLAMA_HOST: 'http://localhost:11434' }).baseUrl, 'http://localhost:11434');
-
-  assert.equal(resolveOllamaConfig({}, {
-    AGENTSAM_OLLAMA_ENDPOINT: '127.0.0.1:2244',
-    OLLAMA_BASE_URL: 'localhost:3344',
-    OLLAMA_HOST: '0.0.0.0:4444',
-  }).baseUrl, 'http://127.0.0.1:2244');
-
-  assert.equal(resolveOllamaConfig({}, {
-    OLLAMA_BASE_URL: 'localhost:3344',
-    OLLAMA_HOST: '0.0.0.0:4444',
-  }).baseUrl, 'http://localhost:3344');
-
-  assert.equal(resolveOllamaConfig({}, {
-    OLLAMA_HOST: '0.0.0.0:4444',
-  }).baseUrl, 'http://127.0.0.1:4444');
-});
-
-test('Ollama setup args require explicit install/pull/start opt-ins', () => {
-  assert.deepEqual(parseOllamaArgs(['setup']), {
-    command: 'setup',
-    cwd: process.cwd(),
-    envFile: '',
-    baseUrl: '',
-    model: '',
-    embedModel: '',
-    install: false,
-    start: false,
-    pull: false,
-    json: false,
-  });
-  const opted = parseOllamaArgs(['setup', '--install', '--start', '--pull', '--json']);
-  assert.equal(opted.install, true);
-  assert.equal(opted.start, true);
-  assert.equal(opted.pull, true);
-  assert.equal(opted.json, true);
-});
-
-test('setup env writer updates only canonical OLLAMA keys and preserves other config', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-ollama-'));
-  const envFile = path.join(root, '.env');
-  fs.writeFileSync(envFile, 'EXISTING=value\nOLLAMA_MODEL=old\n');
-  upsertOllamaEnvFile(envFile, OLLAMA_DEFAULTS);
-  const text = fs.readFileSync(envFile, 'utf8');
-  assert.match(text, /^EXISTING=value$/m);
-  assert.match(text, /^OLLAMA_BASE_URL=http:\/\/127\.0\.0\.1:11434$/m);
-  assert.match(text, /^OLLAMA_MODEL=qwen2\.5-coder$/m);
-  assert.match(text, /^OLLAMA_EMBED_MODEL=mxbai-embed-large$/m);
-  assert.equal((text.match(/^OLLAMA_MODEL=/gm) || []).length, 1);
-});
-
-test('project config records only portable Ollama capability metadata', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-ollama-config-'));
-  fs.mkdirSync(path.join(root, '.agentsam'));
-  fs.writeFileSync(path.join(root, '.agentsam', 'config.json'), `${JSON.stringify(createProjectManifest({ projectName: 'demo', repositoryId: 'local:demo' }), null, 2)}\n`);
-  const filename = updateProjectOllamaConfig(root, OLLAMA_DEFAULTS);
-  const config = JSON.parse(fs.readFileSync(filename, 'utf8'));
-  assert.equal(config.models.local.provider, 'ollama');
-  assert.equal(config.models.local.base_url_env, 'OLLAMA_BASE_URL');
-  assert.equal(config.models.local.model_env, 'OLLAMA_MODEL');
-  assert.equal(config.models.local.embed_model_env, 'OLLAMA_EMBED_MODEL');
-  assert.equal(JSON.stringify(config).includes('127.0.0.1'), false);
-  assert.equal(JSON.stringify(config).includes('qwen2.5-coder'), false);
-  assert.equal(JSON.stringify(config).includes('token'), false);
-});
-
-test('status probe recognizes configured chat and embedding models', async () => {
-  const fakeFetch = async () => new Response(JSON.stringify({ models: [
-    { name: 'qwen2.5-coder:latest' },
-    { name: 'mxbai-embed-large:latest' },
-  ] }), { status: 200, headers: { 'content-type': 'application/json' } });
-  const status = await probeOllama(OLLAMA_DEFAULTS, fakeFetch);
-  assert.equal(status.online, true);
-  assert.equal(status.chat_ready, true);
-  assert.equal(status.embed_ready, true);
-});
-
-test('local model metadata is accepted only after Ollama itself verifies the model', async () => {
-  let seenBody = null;
-  const fakeFetch = async (url, init) => {
-    assert.match(url, /\/api\/show$/);
-    seenBody = JSON.parse(init.body);
-    return new Response(JSON.stringify({
-      model_info: { 'qwen2.context_length': 32768 },
-      capabilities: ['completion', 'tools'],
-      details: { family: 'qwen2' },
-    }), { status: 200, headers: { 'content-type': 'application/json' } });
-  };
-
-  const result = await probeOllamaModel('qwen2.5-coder', OLLAMA_DEFAULTS, fakeFetch);
-  assert.equal(seenBody.model, 'qwen2.5-coder');
-  assert.equal(result.ok, true);
-  assert.equal(result.context_window, 32768);
-  assert.equal(result.context_window_source, 'local_runtime');
-  assert.deepEqual(result.capabilities, ['completion', 'tools']);
-});
-
-test('automatic install plans use local package managers, never a remote shell script', () => {
-  assert.deepEqual(ollamaInstallPlan('darwin', { brew: true }), {
-    command: 'brew', args: ['install', 'ollama'], manager: 'homebrew',
-  });
-  assert.equal(ollamaInstallPlan('linux', { brew: false }), null);
-  assert.equal(ollamaInstallPlan('darwin', { brew: false }), null);
-  const win = ollamaInstallPlan('win32', { winget: true });
-  assert.equal(win.command, 'winget');
-  assert.equal(win.args.includes('Ollama.Ollama'), true);
-});

package/test/open-url.test.mjs

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