badgr-cli 1.0.31 → 1.0.34

package/src/fallback.js

@@ -0,0 +1,219 @@
+import readline from 'readline';
+import { CATALOG, formatCliError } from './errors.js';
+
+// ── Shared routing helpers ────────────────────────────────────────────────────
+
+/** Rates above this threshold trigger a visible warning when no --max-cost is set. */
+export const HIGH_RATE_THRESHOLD = 3.00;
+
+/** Normalise --tier flag variants to '1' or '2'. */
+export function normalizeTier(tier) {
+  return (tier === '2' || tier === 'tier2' || tier === 'tier-2') ? '2' : (tier || '1');
+}
+
+/**
+ * Sentinel error thrown when callWithFallback cannot provision capacity.
+ * The message is already formatted for display; callers should print it and exit.
+ */
+export class CapacityError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'CapacityError';
+    this.isCapacityError = true;
+  }
+}
+
+/**
+ * Call an API endpoint with automatic tier-2 expansion on NO_CAPACITY_MATCH.
+ * Returns the deployment object on success.
+ * Throws CapacityError (pre-formatted for display) on unrecoverable failure.
+ * Re-throws payment errors (err.isPaymentRequired) for callers to handle.
+ *
+ * @param {string}   endpoint          - '/run' or '/serve'
+ * @param {object}   callOpts          - { apiKey, baseUrl }
+ * @param {function} buildBody         - (tierOverride?) => body object
+ * @param {string}   effectiveTier
+ * @param {object}   chalk
+ * @param {object}   labels            - { thing: 'job'|'endpoint', cmd: 'badgr run'|'badgr serve' }
+ * @param {object}   [opts]
+ * @param {boolean}  [opts.allowTier2Fallback=true] - set false to disable tier-2 expansion
+ */
+export async function callWithFallback(endpoint, callOpts, buildBody, effectiveTier, chalk, labels, opts = {}) {
+  const { callApi } = await import('./api.js');
+  const thing = labels?.thing ?? 'job';
+  const cmd   = labels?.cmd   ?? 'badgr run';
+  const allowTier2Fallback = opts.allowTier2Fallback !== false; // default true
+
+  // 75s: backend provisioning runs up to 55s and returns PROVISIONING_TIMEOUT;
+  // the extra headroom ensures the CLI always sees the real response.
+  async function attempt(body) {
+    return callApi(endpoint, { method: 'POST', ...callOpts, body, timeoutMs: 75_000 });
+  }
+
+  // Map server error codes → catalog keys and extract context for templates.
+  function buildCapacityError(err, isFallback) {
+    const d    = err.errorData ?? {};
+    const code = d.code ?? '';
+
+    // Internal fields: shown only with BADGR_DEBUG=1
+    const internal = {
+      ...(d.debug_error ? { detail: d.debug_error } : {}),
+      ...(d.filters     ? { filters: JSON.stringify(d.filters) } : {}),
+    };
+
+    // Map server codes → catalog keys + context
+    const serverToKey = {
+      NO_CAPACITY:           'NO_CAPACITY',
+      NO_CAPACITY_MATCH:     'NO_CAPACITY',
+      PROVISIONING_TIMEOUT:  'PROVISIONING_TIMEOUT',
+      PROVISIONING_FAILED:   'PROVISIONING_FAILED',
+      PROVIDER_ADAPTER_ERROR:'PROVISIONING_FAILED',
+      INVALID_GPU:           'INVALID_GPU',
+      INVALID_MODEL:         'INVALID_MODEL',
+      INSUFFICIENT_VRAM:     'INSUFFICIENT_VRAM',
+      MAX_COST_TOO_LOW:      'MAX_COST_TOO_LOW',
+    };
+
+    const key = serverToKey[code];
+    if (key) {
+      const ctx = {
+        gpu:              d.filters?.gpu ?? d.gpu,
+        region:           d.filters?.region,
+        failure_category: d.failure_category,
+        low_cost_failed:  d.low_cost_provider_failed,
+        server_message:   d.message,
+        alternatives:     d.alternatives,
+      };
+      return new CapacityError(formatCliError(key, ctx, chalk, internal));
+    }
+
+    // Unknown / generic error — safe fallback with no internal details exposed
+    const fallbackMsg =
+      chalk.red(`\n  ✗ Could not start ${thing}: ${err.message}\n`) +
+      chalk.dim(`  Run BADGR_DEBUG=1 ${cmd} … for a full trace.`) +
+      (!isFallback ? '\n' + chalk.dim('  Check config: badgr config\n') : '');
+    return new CapacityError(fallbackMsg);
+  }
+
+  // First attempt
+  let firstErr;
+  try {
+    return await attempt(buildBody());
+  } catch (err) {
+    if (err.isPaymentRequired) throw err;
+    firstErr = err;
+  }
+
+  const d = firstErr.errorData;
+
+  // Stale-capacity retry: PROVISIONING_FAILED means a GPU slot appeared available but
+  // couldn't launch. Retry once immediately to pick up a fresh slot before escalating.
+  if (d?.code === 'PROVISIONING_FAILED' || d?.code === 'PROVIDER_ADAPTER_ERROR') {
+    console.log(chalk.dim('\n  Provisioning failed — retrying with fresh capacity...\n'));
+    try {
+      return await attempt(buildBody());
+    } catch (retryErr) {
+      if (retryErr.isPaymentRequired) throw retryErr;
+      firstErr = retryErr;
+    }
+  }
+
+  // Tier-2 expansion: try budget-tier providers when primary has no capacity
+  if (firstErr.errorData?.code === 'NO_CAPACITY_MATCH' && effectiveTier !== '2' && allowTier2Fallback) {
+    console.log(chalk.dim('\n  Primary capacity unavailable — expanding search...\n'));
+    try {
+      return await attempt(buildBody('2'));
+    } catch (err2) {
+      throw buildCapacityError(err2, true);
+    }
+  }
+
+  throw buildCapacityError(firstErr, false);
+}
+
+// ── GPU fallback prompt ───────────────────────────────────────────────────────
+
+// GPU descriptions for display only — no scoring logic lives here.
+const GPU_DISPLAY = {
+  RTX_3080: { desc: 'Dev, light inference' },
+  RTX_3090: { desc: 'Dev, inference' },
+  RTX_4080: { desc: 'Inference and dev workloads' },
+  RTX_4090: { desc: 'Inference, training, dev' },
+  L40S:     { desc: 'Inference, vLLM, batch jobs' },
+  A6000:    { desc: 'Training, large models, inference' },
+  A100:     { desc: 'Large-scale training and inference' },
+  H100:     { desc: 'Large model training, best throughput' },
+};
+
+/**
+ * Sort alternatives for display.
+ */
+export function rankAlternatives(requestedGpu, alternatives, mode = 'closest') {
+  if (!alternatives || alternatives.length === 0) return [];
+  if (mode === 'cheapest') return [...alternatives].sort((a, b) => a.price - b.price);
+  if (alternatives.some(a => a.rank != null)) {
+    return [...alternatives].sort((a, b) => (a.rank ?? 999) - (b.rank ?? 999));
+  }
+  return [...alternatives].sort((a, b) => a.price - b.price);
+}
+
+/**
+ * One-line diff for display.
+ */
+export function diffDescription(requestedGpu, altGpu, alt = {}) {
+  return alt.diff_desc || '';
+}
+
+function ask(prompt) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => rl.question(prompt, ans => { rl.close(); resolve(ans.trim()); }));
+}
+
+/**
+ * Show the interactive fallback prompt and return the chosen alternative or null.
+ * Non-TTY environments auto-select the top-ranked option.
+ */
+export async function promptFallback(requestedGpu, ranked, chalk) {
+  if (ranked.length === 0) return null;
+
+  const top    = ranked[0];
+  const others = ranked.slice(1, 4);
+  const topDisp = GPU_DISPLAY[top.gpu];
+
+  console.log(chalk.yellow(`\n  ${requestedGpu} isn't available right now.\n`));
+  console.log(chalk.bold('  Closest match:'));
+  console.log(`    ${chalk.cyan(top.gpu)} in ${top.region}`);
+  console.log(`    ${chalk.green('$' + top.price.toFixed(2) + '/hr')} estimated price`);
+  if (top.diff_desc) console.log(`    ${chalk.dim(top.diff_desc)}`);
+  else if (topDisp?.desc) console.log(`    ${topDisp.desc}`);
+  console.log(chalk.dim('    (availability estimated from market data — not pre-verified)'));
+  console.log();
+
+  if (!process.stdin.isTTY) {
+    console.log(chalk.dim(`  Auto-selecting ${top.gpu} (non-interactive).`));
+    return top;
+  }
+
+  console.log(`  Press ${chalk.bold('Enter')} to run on ${chalk.cyan(top.gpu)}`);
+  if (others.length > 0) {
+    console.log('  or type:');
+    for (const [i, alt] of others.entries()) {
+      const disp = GPU_DISPLAY[alt.gpu];
+      const hint = disp ? disp.desc.split(',')[0].toLowerCase() : '';
+      console.log(`    ${chalk.bold(String(i + 1))} = ${alt.gpu}${hint ? ', ' + hint : ''}`);
+    }
+  }
+  console.log(`    ${chalk.bold('q')} = cancel`);
+  console.log();
+
+  const answer = await ask('  > ');
+
+  if (answer === '') return top;
+  if (answer.toLowerCase() === 'q') return null;
+
+  const idx = parseInt(answer, 10);
+  if (!isNaN(idx) && idx >= 1 && idx <= others.length) return others[idx - 1];
+
+  console.log(chalk.dim(`  Unrecognised input — using ${top.gpu}.`));
+  return top;
+}

package/src/router.js

@@ -1,56 +1,27 @@
 /**
- * GPU catalog and routing preview.
+ * GPU catalog — static display info only (name, VRAM, tags, indicative rate).
  *
- * Provider pricing mirrors the order in overflow_providers.py:
- * Vast.ai → RunPod → TensorDock → SaladCloud.
- * Actual routing happens server-side; this is the dry-run preview.
+ * ratePerHour values are indicative market averages for reference display.
+ * Actual billing is always set by the backend and returned as cost_per_hour
+ * on every deployment response. For live rates, use GET /v1/gpus.
+ *
+ * Provider routing logic lives entirely in the backend.
  */
 
 export const GPU_CATALOG = [
-  { id: 'rtx-3080',  canonical: 'RTX_3080', name: 'NVIDIA RTX 3080',  vramGb: 10, ratePerHour: 0.35, tags: ['inference', 'dev'] },
-  { id: 'rtx-4090',  canonical: 'RTX_4090', name: 'NVIDIA RTX 4090',  vramGb: 24, ratePerHour: 1.10, tags: ['inference', 'training', 'dev'] },
-  { id: 'l40s',      canonical: 'L40S',     name: 'NVIDIA L40S',      vramGb: 48, ratePerHour: 1.40, tags: ['inference', 'training'] },
-  { id: 'a6000',     canonical: 'A6000',    name: 'NVIDIA RTX A6000', vramGb: 48, ratePerHour: 1.60, tags: ['inference', 'training'] },
-  { id: 'a100-40gb', canonical: 'A100',     name: 'NVIDIA A100 40GB',  vramGb: 40, ratePerHour: 1.80, tags: ['training', 'inference'] },
-  { id: 'a100-80gb', canonical: 'A100',     name: 'NVIDIA A100 80GB',  vramGb: 80, ratePerHour: 2.50, tags: ['training', 'large-model'] },
-  { id: 'h100',      canonical: 'H100',     name: 'NVIDIA H100 80GB',  vramGb: 80, ratePerHour: 3.50, tags: ['training', 'large-model'] },
+  { id: 'rtx-3080',  canonical: 'RTX_3080',  name: 'NVIDIA RTX 3080',   vramGb: 10, ratePerHour: 0.35, tags: ['inference', 'dev'] },
+  { id: 'rtx-3090',  canonical: 'RTX_3090',  name: 'NVIDIA RTX 3090',   vramGb: 24, ratePerHour: 0.60, tags: ['inference', 'dev'] },
+  { id: 'a4000',     canonical: 'A4000',      name: 'NVIDIA RTX A4000',  vramGb: 16, ratePerHour: 0.50, tags: ['inference', 'dev'] },
+  { id: 'a5000',     canonical: 'A5000',      name: 'NVIDIA RTX A5000',  vramGb: 24, ratePerHour: 0.70, tags: ['inference', 'dev'] },
+  { id: 'rtx-4080',  canonical: 'RTX_4080',  name: 'NVIDIA RTX 4080',   vramGb: 16, ratePerHour: 0.75, tags: ['inference', 'dev'] },
+  { id: 'rtx-4090',  canonical: 'RTX_4090',  name: 'NVIDIA RTX 4090',   vramGb: 24, ratePerHour: 1.10, tags: ['inference', 'training', 'dev'] },
+  { id: 'l40s',      canonical: 'L40S',       name: 'NVIDIA L40S',       vramGb: 48, ratePerHour: 1.40, tags: ['inference', 'training'] },
+  { id: 'a6000',     canonical: 'A6000',      name: 'NVIDIA RTX A6000',  vramGb: 48, ratePerHour: 1.60, tags: ['inference', 'training'] },
+  { id: 'a100-40gb', canonical: 'A100',       name: 'NVIDIA A100 40GB',  vramGb: 40, ratePerHour: 1.80, tags: ['training', 'inference'] },
+  { id: 'a100-80gb', canonical: 'A100_80GB',  name: 'NVIDIA A100 80GB',  vramGb: 80, ratePerHour: 2.50, tags: ['training', 'large-model'] },
+  { id: 'h100',      canonical: 'H100',       name: 'NVIDIA H100 80GB',  vramGb: 80, ratePerHour: 3.50, tags: ['training', 'large-model'] },
 ];
 
-// Provider-level pricing per canonical GPU type (ordered cheapest-first per provider).
-// Mirrors overflow_providers.py search ordering: Vast → RunPod → TensorDock → Salad.
-export const PROVIDER_CATALOG = {
-  RTX_3080: [
-    { provider: 'vastai',      ratePerHour: 0.28, reliability: 0.93 },
-    { provider: 'runpod',      ratePerHour: 0.35, reliability: 0.96 },
-    { provider: 'tensordock',  ratePerHour: 0.40, reliability: 0.90 },
-  ],
-  RTX_4090: [
-    { provider: 'vastai',      ratePerHour: 0.65, reliability: 0.94 },
-    { provider: 'runpod',      ratePerHour: 0.72, reliability: 0.97 },
-    { provider: 'tensordock',  ratePerHour: 0.81, reliability: 0.91 },
-    { provider: 'salad',       ratePerHour: 0.89, reliability: 0.89 },
-  ],
-  L40S: [
-    { provider: 'vastai',      ratePerHour: 1.10, reliability: 0.94 },
-    { provider: 'runpod',      ratePerHour: 1.25, reliability: 0.97 },
-    { provider: 'salad',       ratePerHour: 1.40, reliability: 0.88 },
-  ],
-  A6000: [
-    { provider: 'vastai',      ratePerHour: 1.05, reliability: 0.93 },
-    { provider: 'runpod',      ratePerHour: 1.20, reliability: 0.97 },
-    { provider: 'salad',       ratePerHour: 1.35, reliability: 0.88 },
-  ],
-  A100: [
-    { provider: 'runpod',      ratePerHour: 1.20, reliability: 0.98 },
-    { provider: 'vastai',      ratePerHour: 1.35, reliability: 0.95 },
-    { provider: 'tensordock',  ratePerHour: 1.50, reliability: 0.92 },
-  ],
-  H100: [
-    { provider: 'runpod',      ratePerHour: 2.80, reliability: 0.99 },
-    { provider: 'vastai',      ratePerHour: 3.10, reliability: 0.96 },
-  ],
-};
-
 export function findById(id) {
   return GPU_CATALOG.find(g => g.id === id) ?? null;
 }
@@ -72,33 +43,6 @@ export function listAll() {
   return [...GPU_CATALOG].sort((a, b) => a.ratePerHour - b.ratePerHour);
 }
 
-/**
- * Build the routing preview shown in --dry-run output.
- * Mirrors the lane 1→2→3 logic in overflow_dispatch.py.
- */
-export function getRoutePlan(canonical, count = 1) {
-  const providers = PROVIDER_CATALOG[canonical] ?? [];
-  const sorted = [...providers].sort((a, b) => a.ratePerHour - b.ratePerHour);
-
-  const cheapest = sorted[0];
-  const overhead = 0.25; // ~25% overhead: startup risk + failure buffer + badgr margin
-  const costWithOverhead = cheapest ? cheapest.ratePerHour * (1 + overhead) * count : null;
-
-  return {
-    canonical,
-    gpu: findByCanonical(canonical),
-    lane1: { label: 'Own GPU hosts', description: 'checked at runtime against live worker pool' },
-    lane2: sorted.map((p, i) => ({
-      rank: i + 1,
-      provider: p.provider,
-      ratePerHour: p.ratePerHour * count,
-      reliability: p.reliability,
-    })),
-    cheapestRate: cheapest ? cheapest.ratePerHour * count : null,
-    costWithOverhead,
-  };
-}
-
 export function estimateCost(ratePerHour, durationMinutes) {
   return (ratePerHour / 60) * durationMinutes;
 }

package/src/store.js

@@ -1,5 +1,5 @@
 /**
- * Local deployment state — persisted to ~/.gpu/deployments.json.
+ * Local deployment state — persisted to ~/.badgr/deployments.json.
  *
  * Tracks what `gpu up` has provisioned so `gpu down/status/logs/receipts`
  * have something to work with before a backend deployments API exists.
@@ -83,6 +83,15 @@ export function addReceipt(receipt, storeFile = STORE_FILE) {
   return receipt;
 }
 
+export function updateReceipt(receiptId, updates, storeFile = STORE_FILE) {
+  const store = loadStore(storeFile);
+  const idx = store.receipts.findIndex(r => r.receiptId === receiptId);
+  if (idx === -1) return null;
+  store.receipts[idx] = { ...store.receipts[idx], ...updates };
+  saveStore(store, storeFile);
+  return store.receipts[idx];
+}
+
 export function listReceipts(limit = 20, storeFile = STORE_FILE) {
   return loadStore(storeFile).receipts.slice(0, limit);
 }

package/tests/commands.test.js

@@ -1,6 +1,8 @@
-import { describe, it, expect } from 'vitest';
-import { parseRunArgs } from '../src/commands/run.js';
+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', () => {
@@ -43,6 +45,136 @@ describe('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);
+  });
+});
+
+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', () => {
@@ -78,4 +210,116 @@ describe('parseServeArgs', () => {
     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');
+  });
 });

package/tests/config.test.js

@@ -2,7 +2,7 @@ import { describe, it, expect, afterEach } from 'vitest';
 import { tmpdir } from 'os';
 import { join } from 'path';
 import { rmSync, existsSync } from 'fs';
-import { loadConfig, saveConfig, requireApiKey, DEFAULTS } from '../src/config.js';
+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');
@@ -58,6 +58,29 @@ describe('saveConfig', () => {
   });
 });
 
+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');