badgr-cli 1.1.0 → 1.1.2

package/tests/browser.test.js

@@ -1,51 +0,0 @@
-/**
- * Regression test for a real command-injection vector: openBrowser used to
- * build a shell command via string interpolation (`execSync(\`open "${url}"\`)`).
- * url is not always a local constant — onboarding.js passes
- * session.login_url, a backend API response — so a response containing
- * shell metacharacters (e.g. a double quote followed by a command) would
- * have executed arbitrary shell commands on the user's machine. Every test
- * that exercises onboarding.js mocks browser.js entirely, so this file
- * itself was never actually run by any existing test.
- *
- * Fixed with execFileSync (argv array, no shell) — this test asserts the
- * fix directly: no shell ever sees url as a string to parse.
- */
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-const mockExecFileSync = vi.fn();
-vi.mock('child_process', () => ({ execFileSync: (...args) => mockExecFileSync(...args) }));
-
-const { openBrowser } = await import('../src/browser.js');
-
-describe('openBrowser', () => {
-  const maliciousUrl = 'https://example.com/"; touch /tmp/pwned; echo "';
-
-  beforeEach(() => {
-    mockExecFileSync.mockReset();
-  });
-
-  it('darwin: passes the URL as a single argv element, never a shell string', () => {
-    vi.spyOn(process, 'platform', 'get').mockReturnValue('darwin');
-    openBrowser(maliciousUrl);
-    expect(mockExecFileSync).toHaveBeenCalledWith('open', [maliciousUrl]);
-  });
-
-  it('linux: passes the URL as a single argv element, never a shell string', () => {
-    vi.spyOn(process, 'platform', 'get').mockReturnValue('linux');
-    openBrowser(maliciousUrl);
-    expect(mockExecFileSync).toHaveBeenCalledWith('xdg-open', [maliciousUrl]);
-  });
-
-  it('win32: passes the URL as a single argv element, never a shell string', () => {
-    vi.spyOn(process, 'platform', 'get').mockReturnValue('win32');
-    openBrowser(maliciousUrl);
-    expect(mockExecFileSync).toHaveBeenCalledWith('cmd', ['/c', 'start', '', maliciousUrl]);
-  });
-
-  it('never throws even if execFileSync fails — caller always has the printed URL as fallback', () => {
-    vi.spyOn(process, 'platform', 'get').mockReturnValue('darwin');
-    mockExecFileSync.mockImplementation(() => { throw new Error('no such command'); });
-    expect(() => openBrowser(maliciousUrl)).not.toThrow();
-  });
-});

package/tests/capacity.test.js

@@ -1,68 +0,0 @@
-/**
- * badgr capacity — price-cap behavior
- *
- * Regression coverage: `badgr capacity` used to silently default to
- * --max-price 10 and print misleading "under $10.00/hr" messaging even
- * though the user never asked for a cap. It should now omit max_price
- * entirely unless the user passes --max-price, and only mention a price
- * ceiling in output when one was actually requested.
- */
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-vi.mock('../src/api.js', () => ({
-  callApi: vi.fn(),
-}));
-
-import * as api from '../src/api.js';
-import { capacityCommand } from '../src/commands/capacity.js';
-
-const config = { apiKey: 'test-key', baseUrl: 'https://api.test' };
-const chalk = new Proxy({}, { get: () => (s) => s });
-
-function urlParams(callIndex = 0) {
-  const url = api.callApi.mock.calls[callIndex][0];
-  return new URLSearchParams(url.split('?')[1] ?? '');
-}
-
-describe('capacityCommand price cap', () => {
-  beforeEach(() => {
-    api.callApi.mockReset();
-  });
-
-  it('omits max_price from /capacity/auto when --max-price is not passed', async () => {
-    api.callApi.mockResolvedValueOnce({ gpu: 'RTX_4090', region: 'US', price: 0.17 });
-    await capacityCommand(config, [], chalk);
-    expect(urlParams().has('max_price')).toBe(false);
-  });
-
-  it('sends max_price on /capacity/auto when --max-price is passed', async () => {
-    api.callApi.mockResolvedValueOnce({ gpu: 'RTX_4090', region: 'US', price: 0.17 });
-    await capacityCommand(config, ['--max-price', '5'], chalk);
-    expect(urlParams().get('max_price')).toBe('5');
-  });
-
-  it('omits max_price from /capacity/suggestions when --max-price is not passed', async () => {
-    api.callApi.mockResolvedValueOnce({ matches: [], alternatives: [] });
-    await capacityCommand(config, ['--gpu', '5090'], chalk);
-    expect(urlParams().has('max_price')).toBe(false);
-  });
-
-  it('does not mention a price ceiling in the no-match message when none was requested', async () => {
-    api.callApi.mockResolvedValueOnce({ matches: [], alternatives: [] });
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    await capacityCommand(config, ['--gpu', '5090'], chalk);
-    const output = logSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-    logSpy.mockRestore();
-    expect(output).toContain('No 5090 available right now.');
-    expect(output).not.toContain('under $');
-  });
-
-  it('mentions the price ceiling in the no-match message when --max-price was passed', async () => {
-    api.callApi.mockResolvedValueOnce({ matches: [], alternatives: [] });
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    await capacityCommand(config, ['--gpu', '5090', '--max-price', '10'], chalk);
-    const output = logSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-    logSpy.mockRestore();
-    expect(output).toContain('under $10.00/hr');
-  });
-});

package/tests/commands.test.js

@@ -1,417 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { parseRunArgs, classifyFailure } from '../src/commands/run.js';
-import { parseServeArgs } from '../src/commands/serve.js';
-import { testCommand, parseTestArgs } from '../src/commands/test-run.js';
-import { rankAlternatives, diffDescription, promptFallback, CapacityError } from '../src/fallback.js';
-
-describe('parseRunArgs', () => {
-  it('parses a plain command', () => {
-    const { flags, positional } = parseRunArgs(['python', 'train.py']);
-    expect(positional).toEqual(['python', 'train.py']);
-    expect(flags.gpu).toBeUndefined();
-  });
-
-  it('parses --gpu flag', () => {
-    const { flags, positional } = parseRunArgs(['python', 'train.py', '--gpu', 'A100']);
-    expect(positional).toEqual(['python', 'train.py']);
-    expect(flags.gpu).toBe('A100');
-  });
-
-  it('parses --image flag', () => {
-    const { flags } = parseRunArgs(['--image', 'my/image:latest', '--gpu', 'L40S']);
-    expect(flags.image).toBe('my/image:latest');
-    expect(flags.gpu).toBe('L40S');
-  });
-
-  it('parses --max-price flag', () => {
-    const { flags } = parseRunArgs(['python', 'run.py', '--max-price', '2.5']);
-    expect(flags.maxPrice).toBe(2.5);
-  });
-
-  it('parses --detach flag', () => {
-    const { flags, positional } = parseRunArgs(['python', 'train.py', '--gpu', 'A100', '--detach']);
-    expect(positional).toEqual(['python', 'train.py']);
-    expect(flags.detach).toBe(true);
-    expect(flags.gpu).toBe('A100');
-  });
-
-  it('detach defaults to falsy when not passed', () => {
-    const { flags } = parseRunArgs(['python', 'train.py']);
-    expect(flags.detach).toBeFalsy();
-  });
-
-  it('returns empty positional and flags for empty args', () => {
-    const { flags, positional } = parseRunArgs([]);
-    expect(positional).toEqual([]);
-    expect(flags.gpu).toBeUndefined();
-  });
-
-  it('parses --fallback closest', () => {
-    const { flags } = parseRunArgs(['python', 'train.py', '--gpu', 'A100', '--fallback', 'closest']);
-    expect(flags.fallback).toBe('closest');
-    expect(flags.noFallback).toBeUndefined();
-  });
-
-  it('parses --fallback cheapest', () => {
-    const { flags } = parseRunArgs(['python', 'train.py', '--fallback', 'cheapest']);
-    expect(flags.fallback).toBe('cheapest');
-  });
-
-  it('parses --no-fallback', () => {
-    const { flags } = parseRunArgs(['python', 'train.py', '--gpu', 'A100', '--no-fallback']);
-    expect(flags.noFallback).toBe(true);
-    expect(flags.fallback).toBeUndefined();
-  });
-
-  it('parses --max-runtime as a float (minutes)', () => {
-    const { flags } = parseRunArgs(['python', 'train.py', '--max-runtime', '30']);
-    expect(flags.maxRuntime).toBe(30);
-  });
-
-  it('parses --max-cost as a float (dollars)', () => {
-    const { flags } = parseRunArgs(['python', 'train.py', '--max-cost', '5.00']);
-    expect(flags.maxCost).toBe(5.0);
-  });
-
-  it('parses --tier 2 flag', () => {
-    const { flags } = parseRunArgs(['python', 'train.py', '--tier', '2']);
-    expect(flags.tier).toBe('2');
-  });
-
-  it('--tier defaults to undefined when not passed', () => {
-    const { flags } = parseRunArgs(['python', 'train.py']);
-    expect(flags.tier).toBeUndefined();
-  });
-
-  it('parses --min-vram flag', () => {
-    const { flags } = parseRunArgs(['python', 'job.py', '--min-vram', '24']);
-    expect(flags.minVram).toBe(24);
-    expect(flags.gpu).toBeUndefined();
-  });
-
-  it('--min-vram and --gpu can be combined', () => {
-    const { flags } = parseRunArgs(['python', 'job.py', '--gpu', 'A100', '--min-vram', '40']);
-    expect(flags.gpu).toBe('A100');
-    expect(flags.minVram).toBe(40);
-  });
-
-  it('parses --gpu-memory as a GB-parsed alias for --min-vram', () => {
-    const { flags } = parseRunArgs(['python', 'job.py', '--gpu-memory', '24GB']);
-    expect(flags.minVram).toBe(24);
-  });
-
-  it('--gpu-memory accepts a bare number (assumed GB)', () => {
-    const { flags } = parseRunArgs(['python', 'job.py', '--gpu-memory', '40']);
-    expect(flags.minVram).toBe(40);
-  });
-
-  it('parses --cpu as an integer core count', () => {
-    const { flags } = parseRunArgs(['python', 'job.py', '--cpu', '16']);
-    expect(flags.cpu).toBe(16);
-  });
-
-  it('parses --memory with a GB/MB suffix into a GB float', () => {
-    const { flags: gb } = parseRunArgs(['python', 'job.py', '--memory', '64GB']);
-    expect(gb.memory).toBe(64);
-    const { flags: mb } = parseRunArgs(['python', 'job.py', '--memory', '65536MB']);
-    expect(mb.memory).toBeCloseTo(64);
-  });
-
-  it('--cpu, --memory, --gpu-memory can all be combined', () => {
-    const { flags } = parseRunArgs(['python', 'job.py', '--cpu', '16', '--memory', '64GB', '--gpu-memory', '24GB']);
-    expect(flags.cpu).toBe(16);
-    expect(flags.memory).toBe(64);
-    expect(flags.minVram).toBe(24);
-  });
-
-  it('parses --no-gpu', () => {
-    const { flags } = parseRunArgs(['python', 'sim.py', '--no-gpu', '--cpu', '16', '--memory', '64GB']);
-    expect(flags.noGpu).toBe(true);
-    expect(flags.cpu).toBe(16);
-    expect(flags.memory).toBe(64);
-  });
-
-  it('-- separator: badgr flags before --, command argv after', () => {
-    const { flags, commandArgv, positional } = parseRunArgs([
-      '--gpu', 'RTX_4090', '--image', 'node:20', '--max-cost', '1', '--',
-      'node', '-e', "console.log('hello')",
-    ]);
-    expect(flags.gpu).toBe('RTX_4090');
-    expect(flags.image).toBe('node:20');
-    expect(flags.maxCost).toBe(1);
-    expect(commandArgv).toEqual(['node', '-e', "console.log('hello')"]);
-    expect(positional).toEqual([]);
-  });
-
-  it('-- separator: commandArgv is empty array when nothing follows --', () => {
-    const { commandArgv } = parseRunArgs(['--gpu', 'A100', '--max-cost', '2', '--']);
-    expect(commandArgv).toEqual([]);
-  });
-
-  it('commandArgv is null when -- is not used (legacy syntax)', () => {
-    const { commandArgv, positional } = parseRunArgs(['python', 'train.py', '--gpu', 'A100']);
-    expect(commandArgv).toBeNull();
-    expect(positional).toEqual(['python', 'train.py']);
-  });
-
-  it('parses --dry-run flag', () => {
-    const { flags } = parseRunArgs(['--dry-run', '--gpu', 'RTX_4090', '--image', 'node:20']);
-    expect(flags.dryRun).toBe(true);
-    expect(flags.gpu).toBe('RTX_4090');
-  });
-
-  it('--dry-run with -- separator keeps command argv intact', () => {
-    const { flags, commandArgv } = parseRunArgs([
-      '--dry-run', '--gpu', 'RTX_4090', '--image', 'node:20', '--',
-      'node', '-e', "console.log('dry')",
-    ]);
-    expect(flags.dryRun).toBe(true);
-    expect(commandArgv).toEqual(['node', '-e', "console.log('dry')"]);
-  });
-
-  it('-- separator: command tokens with --flags are not parsed as badgr flags', () => {
-    // --json is a user command flag here, not a badgr flag
-    const { flags, commandArgv } = parseRunArgs([
-      '--gpu', 'A100', '--max-cost', '2', '--',
-      'gpu-monitor', 'check', '--json',
-    ]);
-    expect(commandArgv).toEqual(['gpu-monitor', 'check', '--json']);
-    expect(flags.gpu).toBe('A100');
-  });
-});
-
-describe('classifyFailure', () => {
-  it('returns infrastructure when status is failed and no exit code', () => {
-    expect(classifyFailure('failed', null)).toBe('infrastructure');
-    expect(classifyFailure('failed', undefined)).toBe('infrastructure');
-  });
-
-  it('returns customer_code when exit code is non-zero', () => {
-    expect(classifyFailure('failed', 1)).toBe('customer_code');
-    expect(classifyFailure('completed', 2)).toBe('customer_code');
-  });
-
-  it('returns null for successful jobs', () => {
-    expect(classifyFailure('completed', 0)).toBeNull();
-    expect(classifyFailure('completed', null)).toBeNull();
-  });
-
-  it('returns null for stopped jobs with no exit code', () => {
-    expect(classifyFailure('stopped', null)).toBeNull();
-  });
-});
-
-describe('rankAlternatives', () => {
-  const pool = [
-    { gpu: 'RTX_4090', region: 'US', price: 0.72, rank: 3 },
-    { gpu: 'L40S',     region: 'US', price: 1.25, rank: 2 },
-    { gpu: 'H100',     region: 'EU', price: 2.80, rank: 1 },
-    { gpu: 'A6000',    region: 'US', price: 1.20 },   // no rank field
-  ];
-
-  it('cheapest mode sorts by price ascending', () => {
-    const ranked = rankAlternatives('A100', pool, 'cheapest');
-    expect(ranked[0].price).toBe(0.72);
-    expect(ranked[ranked.length - 1].price).toBe(2.80);
-  });
-
-  it('closest mode honours backend rank field when present', () => {
-    const poolWithRanks = [
-      { gpu: 'RTX_4090', region: 'US', price: 0.72, rank: 3 },
-      { gpu: 'L40S',     region: 'US', price: 1.25, rank: 2 },
-      { gpu: 'H100',     region: 'EU', price: 2.80, rank: 1 },
-    ];
-    const ranked = rankAlternatives('A100', poolWithRanks, 'closest');
-    expect(ranked[0].gpu).toBe('H100');   // rank 1 → top
-    expect(ranked[1].gpu).toBe('L40S');   // rank 2
-    expect(ranked[2].gpu).toBe('RTX_4090'); // rank 3
-  });
-
-  it('closest mode falls back to price sort when no rank field', () => {
-    const noRankPool = [
-      { gpu: 'RTX_4090', region: 'US', price: 0.72 },
-      { gpu: 'L40S',     region: 'US', price: 1.25 },
-    ];
-    const ranked = rankAlternatives('A100', noRankPool, 'closest');
-    expect(ranked[0].price).toBe(0.72);
-  });
-
-  it('returns empty array for empty pool', () => {
-    expect(rankAlternatives('A100', [])).toEqual([]);
-  });
-
-  it('returns empty array for null pool', () => {
-    expect(rankAlternatives('A100', null)).toEqual([]);
-  });
-});
-
-describe('diffDescription', () => {
-  it('uses diff_desc from alt object when backend provides it', () => {
-    const alt = { diff_desc: 'less VRAM (24GB vs 40GB) than A100' };
-    expect(diffDescription('A100', 'RTX_4090', alt)).toBe(alt.diff_desc);
-  });
-
-  it('returns empty string when diff_desc is absent', () => {
-    expect(diffDescription('A100', 'RTX_4090', {})).toBe('');
-    expect(diffDescription('A100', 'RTX_4090')).toBe('');
-  });
-
-  it('returns empty string for unknown GPUs with no alt object', () => {
-    expect(diffDescription('UNKNOWN', 'ALSO_UNKNOWN')).toBe('');
-  });
-});
-
-describe('parseServeArgs', () => {
-  it('parses model positional arg', () => {
-    const { model, flags } = parseServeArgs(['meta-llama/Llama-3.1-8B-Instruct', '--gpu', 'L40S']);
-    expect(model).toBe('meta-llama/Llama-3.1-8B-Instruct');
-    expect(flags.gpu).toBe('L40S');
-  });
-
-  it('parses --name flag', () => {
-    const { model, flags } = parseServeArgs(['mistralai/Mistral-7B-v0.1', '--name', 'prod-llm']);
-    expect(model).toBe('mistralai/Mistral-7B-v0.1');
-    expect(flags.name).toBe('prod-llm');
-  });
-
-  it('parses --max-price flag', () => {
-    const { flags } = parseServeArgs(['my/model', '--max-price', '3.0']);
-    expect(flags.maxPrice).toBe(3.0);
-  });
-
-  it('parses --no-wait flag', () => {
-    const { model, flags } = parseServeArgs(['my/model', '--gpu', 'L40S', '--no-wait']);
-    expect(model).toBe('my/model');
-    expect(flags.noWait).toBe(true);
-  });
-
-  it('noWait defaults to falsy when not passed', () => {
-    const { flags } = parseServeArgs(['my/model']);
-    expect(flags.noWait).toBeFalsy();
-  });
-
-  it('returns null model when no positional arg', () => {
-    const { model } = parseServeArgs(['--gpu', 'RTX_4090']);
-    expect(model).toBeNull();
-  });
-
-  it('parses --tier 2 flag', () => {
-    const { flags } = parseServeArgs(['my/model', '--tier', '2']);
-    expect(flags.tier).toBe('2');
-  });
-
-  it('--tier defaults to undefined when not passed', () => {
-    const { flags } = parseServeArgs(['my/model']);
-    expect(flags.tier).toBeUndefined();
-  });
-
-  it('parses --no-fallback as noMarketplaceFallback', () => {
-    const { flags } = parseServeArgs(['my/model', '--no-fallback']);
-    expect(flags.noMarketplaceFallback).toBe(true);
-  });
-
-  it('parses --strict-capacity as noMarketplaceFallback', () => {
-    const { flags } = parseServeArgs(['my/model', '--strict-capacity']);
-    expect(flags.noMarketplaceFallback).toBe(true);
-  });
-
-  it('parses --no-expanded-search as noMarketplaceFallback', () => {
-    const { flags } = parseServeArgs(['my/model', '--no-expanded-search']);
-    expect(flags.noMarketplaceFallback).toBe(true);
-  });
-
-  it('noMarketplaceFallback defaults to falsy when not passed', () => {
-    const { flags } = parseServeArgs(['my/model']);
-    expect(flags.noMarketplaceFallback).toBeFalsy();
-  });
-
-  it('model is not consumed by --no-fallback flag', () => {
-    const { model, flags } = parseServeArgs(['my/model', '--no-fallback']);
-    expect(model).toBe('my/model');
-    expect(flags.noMarketplaceFallback).toBe(true);
-  });
-
-  it('parses --health-path flag', () => {
-    const { flags } = parseServeArgs(['my/model', '--health-path', '/system_stats']);
-    expect(flags.healthPath).toBe('/system_stats');
-  });
-
-  it('parses --health-path with arbitrary path', () => {
-    const { flags } = parseServeArgs(['--image', 'my/image:latest', '--health-path', '/health']);
-    expect(flags.healthPath).toBe('/health');
-  });
-
-  it('healthPath defaults to undefined when not passed', () => {
-    const { flags } = parseServeArgs(['my/model']);
-    expect(flags.healthPath).toBeUndefined();
-  });
-});
-
-describe('testCommand', () => {
-  it('is a function', () => {
-    expect(typeof testCommand).toBe('function');
-  });
-});
-
-describe('parseTestArgs', () => {
-  it('returns empty flags for no args', () => {
-    expect(parseTestArgs([])).toEqual({});
-  });
-
-  it('parses --provider tier1', () => {
-    expect(parseTestArgs(['--provider', 'tier1'])).toEqual({ provider: 'tier1' });
-  });
-
-  it('parses --provider tier2', () => {
-    expect(parseTestArgs(['--provider', 'tier2'])).toEqual({ provider: 'tier2' });
-  });
-
-  it('parses --provider secondary', () => {
-    expect(parseTestArgs(['--provider', 'secondary'])).toEqual({ provider: 'secondary' });
-  });
-
-  it('parses --no-tier-fallback', () => {
-    expect(parseTestArgs(['--no-tier-fallback'])).toEqual({ noTierFallback: true });
-  });
-});
-
-describe('CapacityError', () => {
-  it('is an Error subclass', () => {
-    const err = new CapacityError('no capacity');
-    expect(err).toBeInstanceOf(Error);
-    expect(err.isCapacityError).toBe(true);
-    expect(err.name).toBe('CapacityError');
-    expect(err.message).toBe('no capacity');
-  });
-});
-
-describe('promptFallback output', () => {
-  it('does not print a Difference line', async () => {
-    const lines = [];
-    const chalk = { yellow: s => s, bold: s => s, cyan: s => s, green: s => s, dim: s => s };
-    const origLog = console.log;
-    console.log = (...args) => lines.push(args.join(' '));
-    // force non-TTY so it auto-selects without asking
-    const origIsTTY = process.stdin.isTTY;
-    process.stdin.isTTY = false;
-
-    const pool = [{ gpu: 'L40S', region: 'US', price: 1.25 }];
-    await promptFallback('A100', pool, chalk);
-
-    console.log = origLog;
-    process.stdin.isTTY = origIsTTY;
-
-    const joined = lines.join('\n');
-    expect(joined).not.toContain('Difference');
-    expect(joined).toContain('L40S');
-    expect(joined).toContain('1.25');
-  });
-});
-
-describe('old agent-positional run path (removed)', () => {
-  it('no longer exports isAgentRun/buildAgentRun from run.js', async () => {
-    const mod = await import('../src/commands/run.js');
-    expect(mod.isAgentRun).toBeUndefined();
-    expect(mod.buildAgentRun).toBeUndefined();
-  });
-});

package/tests/config.test.js

@@ -1,96 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { rmSync, existsSync } from 'fs';
-import { loadConfig, saveConfig, requireApiKey, normalizeBaseUrl, DEFAULTS } from '../src/config.js';
-
-const tmp = join(tmpdir(), `badgr-cli-test-${process.pid}`);
-const testConfigFile = join(tmp, 'config.json');
-
-afterEach(() => {
-  if (existsSync(tmp)) rmSync(tmp, { recursive: true, force: true });
-});
-
-describe('loadConfig', () => {
-  it('returns defaults when file does not exist', () => {
-    const config = loadConfig('/nonexistent/path/config.json');
-    expect(config.baseUrl).toBe(DEFAULTS.baseUrl);
-    expect(config.defaultModel).toBe(DEFAULTS.defaultModel);
-    expect(config.apiKey).toBeUndefined();
-  });
-
-  it('merges saved values with defaults', () => {
-    saveConfig({ apiKey: 'sk-test' }, testConfigFile);
-    const config = loadConfig(testConfigFile);
-    expect(config.apiKey).toBe('sk-test');
-    expect(config.baseUrl).toBe(DEFAULTS.baseUrl);
-  });
-
-  it('returns defaults on corrupt file', () => {
-    import('fs').then(({ writeFileSync, mkdirSync }) => {
-      mkdirSync(tmp, { recursive: true });
-      writeFileSync(testConfigFile, '{ invalid json }');
-    });
-    const config = loadConfig(testConfigFile);
-    expect(config.baseUrl).toBe(DEFAULTS.baseUrl);
-  });
-});
-
-describe('saveConfig', () => {
-  it('persists values and returns merged config', () => {
-    const saved = saveConfig({ apiKey: 'sk-123' }, testConfigFile);
-    expect(saved.apiKey).toBe('sk-123');
-    expect(saved.baseUrl).toBe(DEFAULTS.baseUrl);
-  });
-
-  it('merges with existing values', () => {
-    saveConfig({ apiKey: 'original' }, testConfigFile);
-    saveConfig({ baseUrl: 'http://localhost:8000/v1' }, testConfigFile);
-    const config = loadConfig(testConfigFile);
-    expect(config.apiKey).toBe('original');
-    expect(config.baseUrl).toBe('http://localhost:8000/v1');
-  });
-
-  it('creates missing directories', () => {
-    const deepFile = join(tmp, 'deep', 'nested', 'config.json');
-    saveConfig({ apiKey: 'deep' }, deepFile);
-    expect(existsSync(deepFile)).toBe(true);
-  });
-});
-
-describe('normalizeBaseUrl', () => {
-  it('rewrites legacy api.badgr.ai to production host', () => {
-    expect(normalizeBaseUrl('https://api.badgr.ai/v1')).toBe(DEFAULTS.baseUrl);
-    expect(normalizeBaseUrl('https://api.badgr.ai')).toBe(DEFAULTS.baseUrl);
-  });
-
-  it('keeps production and localhost URLs', () => {
-    expect(normalizeBaseUrl('https://api.aibadgr.com/v1')).toBe(DEFAULTS.baseUrl);
-    expect(normalizeBaseUrl('http://localhost:8000/v1')).toBe('http://localhost:8000/v1');
-  });
-});
-
-describe('loadConfig legacy migration', () => {
-  it('migrates saved api.badgr.ai baseUrl on load', () => {
-    saveConfig(
-      { apiKey: 'sk-test', baseUrl: 'https://api.badgr.ai/v1' },
-      testConfigFile,
-    );
-    const config = loadConfig(testConfigFile);
-    expect(config.baseUrl).toBe(DEFAULTS.baseUrl);
-  });
-});
-
-describe('requireApiKey', () => {
-  it('returns the key when present', () => {
-    expect(requireApiKey({ apiKey: 'sk-abc' })).toBe('sk-abc');
-  });
-
-  it('throws an error mentioning `badgr login` when missing', () => {
-    expect(() => requireApiKey({})).toThrow('badgr login');
-  });
-
-  it('throws when apiKey is empty string', () => {
-    expect(() => requireApiKey({ apiKey: '' })).toThrow();
-  });
-});