badgr-cli 1.0.30 → 1.0.31

package/src/commands/serve.js

@@ -1,12 +1,13 @@
 import { requireApiKey } from '../config.js';
-import { addDeployment, addReceipt, updateReceipt, generateReceiptId } from '../store.js';
-import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
+import { callApi } from '../api.js';
+import { addDeployment, addReceipt, generateReceiptId } from '../store.js';
 
 /**
- * badgr serve meta-llama/Llama-3.1-8B-Instruct
  * badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S
  *
- * GPU defaults to "AUTO" — backend infers from model size.
+ * Provisions a persistent vLLM endpoint, health-checks it before printing
+ * "Endpoint ready", and returns an OpenAI-compatible base URL.
+ * Stop billing with `badgr down <id>`.
  */
 export function parseServeArgs(args) {
   const flags = {};
@@ -16,56 +17,33 @@ export function parseServeArgs(args) {
     if (args[i] === '--gpu')        { flags.gpu = args[++i]; i++; continue; }
     if (args[i] === '--count')      { flags.count = parseInt(args[++i], 10); i++; continue; }
     if (args[i] === '--region')     { flags.region = args[++i]; i++; continue; }
-    if (args[i] === '--tier')       { flags.tier = args[++i]; i++; continue; }
     if (args[i] === '--max-price')  { flags.maxPrice = parseFloat(args[++i]); i++; continue; }
     if (args[i] === '--name')       { flags.name = args[++i]; i++; continue; }
-    if (args[i] === '--no-wait')               { flags.noWait = true; i++; continue; }
-    if (args[i] === '--max-cost')              { flags.maxCost = parseFloat(args[++i]); i++; continue; }
-    if (args[i] === '--strict-capacity')    { flags.noMarketplaceFallback = true; i++; continue; }
-    if (args[i] === '--no-expanded-search') { flags.noMarketplaceFallback = true; i++; continue; }
+    if (args[i] === '--no-wait')    { flags.noWait = true; i++; continue; }
     positional.push(args[i++]);
   }
   const model = positional[0] || null;
   return { model, flags };
 }
 
-// Mirror of backend workload_profile.py infer_profile_from_model — for pre-flight display.
-function _inferServeProfile(modelName) {
-  const s = modelName.toLowerCase();
-  const moe = s.match(/(\d+)x(\d+)b/);
-  let paramsB;
-  if (moe) {
-    paramsB = parseInt(moe[1]) * parseInt(moe[2]);
-  } else {
-    const m = s.match(/(\d+)b/);
-    paramsB = m ? parseInt(m[1]) : null;
-  }
-  if (paramsB === null) return { label: 'inference (7B–8B model)', vram: '24+ GB', gpus: ['RTX 4090', 'A6000', 'L40S'] };
-  if (paramsB <= 9)    return { label: 'inference (7B–8B model)', vram: '24+ GB', gpus: ['RTX 4090', 'A6000', 'L40S'] };
-  if (paramsB <= 35)   return { label: 'inference (30B–34B model)', vram: '40+ GB', gpus: ['A6000', 'L40S', 'A100'] };
-  return                      { label: 'inference (70B+ model)',    vram: '80+ GB', gpus: ['H100', 'A100'] };
-}
-
-function _serveStageLabel(elapsedSec) {
-  if (elapsedSec < 45)  return 'Starting vLLM…';
-  if (elapsedSec < 150) return 'Downloading model…';
-  return 'Waiting for /v1/models…';
-}
-
+// Poll GET <endpointUrl>/models until it returns 200 or timeout expires.
+// Returns true if healthy, false if timed out.
 async function waitForEndpoint(endpointUrl, timeoutMs = 5 * 60 * 1000, chalk) {
-  const startMs  = Date.now();
-  const deadline = startMs + timeoutMs;
+  const deadline = Date.now() + timeoutMs;
+  const modelsUrl = `${endpointUrl}/models`;
+  let attempt = 0;
 
   while (Date.now() < deadline) {
+    attempt++;
     try {
-      const res = await fetch(`${endpointUrl}/models`, { signal: AbortSignal.timeout(8000) });
-      if (res.ok) { process.stdout.write('\n'); return true; }
+      const res = await fetch(modelsUrl, { signal: AbortSignal.timeout(8000) });
+      if (res.ok) return true;
     } catch {
-      // still starting
+      // network not up yet — keep polling
     }
-    const elapsed = Math.round((Date.now() - startMs) / 1000);
+    const elapsed = Math.round((Date.now() - (deadline - timeoutMs)) / 1000);
     process.stdout.write(
-      `\r  ${chalk.dim(_serveStageLabel(elapsed) + ` (${elapsed}s)`)}   `
+      `\r  ${chalk.dim(`Waiting for endpoint… ${elapsed}s (attempt ${attempt})`)}   `
     );
     await new Promise(r => setTimeout(r, 8000));
   }
@@ -77,81 +55,42 @@ export async function serveCommand(config, args, chalk) {
   const { model, flags } = parseServeArgs(args);
 
   if (!model) {
-    console.error(chalk.red('Usage: badgr serve <model>'));
-    console.error(chalk.red('       badgr serve meta-llama/Llama-3.1-8B-Instruct'));
+    console.error(chalk.red('Usage: badgr serve <model> --gpu <type>'));
+    console.error(chalk.red('       badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S'));
     return;
   }
 
   requireApiKey(config);
 
-  // gpu=AUTO tells the backend to infer the right GPU from model size
-  const gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : 'AUTO';
-  const gpuLabel = gpu === 'AUTO' ? 'auto' : gpu;
+  const gpu = flags.gpu || 'L40S';
 
-  const effectiveTier = normalizeTier(flags.tier);
-
-  console.log(chalk.bold('\n⚡ Serving model\n'));
+  console.log(chalk.bold('\n🚀 Serving model\n'));
   console.log(`  ${chalk.bold('Model:')}  ${model}`);
-  console.log(`  ${chalk.bold('GPU:')}    ${gpuLabel}`);
-
-  // Show inferred workload so the user knows what Badgr detected.
-  if (gpu === 'AUTO') {
-    const prof = _inferServeProfile(model);
-    console.log();
-    console.log(`  ${chalk.bold('Estimated workload:')}      ${prof.label}`);
-    console.log(`  ${chalk.bold('Estimated minimum VRAM:')}  ${prof.vram}`);
-    if (flags.maxCost) console.log(`  ${chalk.bold('Max cost:')}           $${flags.maxCost.toFixed(2)}`);
-  }
+  console.log(`  ${chalk.bold('GPU:')}    ${gpu}`);
   console.log();
-  process.stdout.write(chalk.dim('  Finding suitable capacity...\n'));
-
-  const effectiveRegion = flags.region ? flags.region.toUpperCase() : undefined;
-
-  function buildBody(gpuOverride, tierOverride) {
-    return {
-      model,
-      gpu: gpuOverride || gpu,
-      gpu_count: flags.count || 1,
-      ...(effectiveRegion ? { region: effectiveRegion } : {}),
-      max_price_per_hour: flags.maxPrice,
-      name: flags.name,
-      tier: tierOverride || effectiveTier,
-    };
-  }
+  console.log(chalk.dim('  Finding best available GPU capacity...'));
 
   let dep;
   try {
-    dep = await callWithFallback(
-      '/serve',
-      { apiKey: config.apiKey, baseUrl: config.baseUrl },
-      (tierOverride) => buildBody(undefined, tierOverride),
-      effectiveTier,
-      chalk,
-      { thing: 'endpoint', cmd: 'badgr serve' },
-    );
-  } catch (err) {
-    const failRcptId = generateReceiptId();
-    addReceipt({
-      receiptId:   failRcptId,
-      action:      'badgr serve',
-      model,
-      gpu: gpuLabel,
-      status:      'failed',
-      failureType: 'infrastructure',
-      createdAt:   new Date().toISOString(),
+    dep = await callApi('/serve', {
+      method: 'POST',
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+      body: {
+        model,
+        gpu: gpu.toUpperCase().replace('-', '_'),
+        gpu_count: flags.count || 1,
+        region: flags.region || 'US',
+        max_price_per_hour: flags.maxPrice,
+        name: flags.name,
+      },
     });
-    if (err.isPaymentRequired) {
-      console.error(chalk.yellow(err.message));
-      const rerun = `badgr serve ${args.join(' ')}`;
-      console.error(chalk.dim(`After payment, rerun:\n  ${rerun}\n`));
-      return;
-    }
-    console.error(chalk.red(`\n  ✗ Could not start endpoint: ${err.message}`));
-    console.error(chalk.dim(`\n  Receipt: ${failRcptId}`));
-    console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr serve … for a full trace.\n`));
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ Serve failed: ${err.message}\n`));
     return;
   }
 
+  // Mirror to local store so badgr down/status/receipts work offline
   addDeployment({
     id:          dep.deployment_id,
     name:        dep.name,
@@ -159,13 +98,12 @@ export async function serveCommand(config, args, chalk) {
     model:       dep.model || model,
     gpu:         dep.gpu_type,
     count:       dep.gpu_count,
+    provider:    dep.provider,
     status:      dep.status,
     endpointUrl: dep.endpoint_url || dep.openai_base_url,
     receiptId:   dep.receipt_id,
     createdAt:   new Date().toISOString(),
     costPerHour: dep.cost_per_hour || 0,
-    providerRoute: dep.provider ?? null,
-    tier:          dep.tier ?? null,
   });
 
   const rcptId = dep.receipt_id || generateReceiptId();
@@ -173,59 +111,49 @@ export async function serveCommand(config, args, chalk) {
     receiptId:    rcptId,
     action:       'badgr serve',
     deploymentId: dep.deployment_id,
+    provider:     dep.provider,
     gpu:          dep.gpu_type,
-    providerRoute: dep.provider ?? null,
-    tier:          dep.tier ?? null,
     status:       dep.status,
     createdAt:    new Date().toISOString(),
   });
 
   const endpointUrl = dep.endpoint_url || dep.openai_base_url || config.baseUrl;
 
-  // ── Health check ──────────────────────────────────────────────────────────
+  // ── Health check before declaring "ready" ─────────────────────────────────
   let endpointReady = false;
+
   if (flags.noWait) {
-    console.log(chalk.yellow('\n  Skipped health check (--no-wait)\n'));
+    console.log(chalk.yellow('\n⏳ Endpoint provisioning (skipped health check — use --no-wait)\n'));
   } else {
+    console.log(chalk.dim('\n  Health-checking endpoint (up to 5 min)...'));
     endpointReady = await waitForEndpoint(endpointUrl, 5 * 60 * 1000, chalk);
     process.stdout.write('\n');
-    if (!endpointReady) updateReceipt(rcptId, { status: 'health_check_timeout' });
   }
 
-  // ── Result ────────────────────────────────────────────────────────────────
+  // ── Print result ──────────────────────────────────────────────────────────
   if (endpointReady) {
-    console.log(chalk.green('\n  ✓ Endpoint ready\n'));
+    console.log(chalk.green('✓ Endpoint ready\n'));
   } else {
-    console.log(chalk.yellow('\n  ⏳ Endpoint still starting — model download may still be in progress.\n'));
-    console.log(`  ${chalk.bold('Stop billing now:')}   ${chalk.dim(`badgr down ${dep.deployment_id}`)}`);
-    console.log(`  ${chalk.bold('Continue watching:')}  ${chalk.dim(`badgr logs ${dep.deployment_id}`)}`);
+    console.log(chalk.yellow('⏳ Endpoint starting\n'));
+    console.log(chalk.dim(`  Not yet responding. Check status:`));
+    console.log(chalk.dim(`    badgr status`));
+    console.log(chalk.dim(`    curl ${endpointUrl}/models`));
     console.log();
   }
 
-  const serveRate = dep.cost_per_hour || 0;
-
-  console.log(`  ${chalk.bold('Base URL:')}     ${chalk.cyan(endpointUrl)}`);
-  console.log(`  ${chalk.bold('Model:')}        ${dep.model || model}`);
-  console.log(`  ${chalk.bold('GPU:')}          ${dep.gpu_type} × ${dep.gpu_count}`);
-  if (serveRate > 0) console.log(`  ${chalk.bold('Rate:')}         $${serveRate.toFixed(2)}/hr`);
-  if (flags.maxCost) console.log(`  ${chalk.bold('Max cost:')}     $${flags.maxCost.toFixed(2)}`);
-  console.log(`  ${chalk.bold('Receipt:')}      ${chalk.dim(rcptId)}`);
-  console.log(`  ${chalk.bold('Logs:')}         ${chalk.dim(`badgr logs ${dep.deployment_id}`)}`);
-  console.log(`  ${chalk.bold('Stop billing:')} ${chalk.cyan(`badgr down ${dep.deployment_id}`)}`);
-  console.log();
-
-  if (serveRate > HIGH_RATE_THRESHOLD && !flags.maxCost) {
-    console.log(chalk.yellow(`  Selected capacity rate: $${serveRate.toFixed(2)}/hr`));
-    console.log(chalk.dim('  Tip: use --max-cost to enforce a hard ceiling.\n'));
-  }
-  console.log(chalk.dim('  Billing continues until you run: ') + chalk.cyan(`badgr down ${dep.deployment_id}`));
+  console.log(`  ${chalk.bold('Deployment:')} ${chalk.cyan(dep.deployment_id)}`);
+  console.log(`  ${chalk.bold('Model:')}      ${dep.model || model}`);
+  console.log(`  ${chalk.bold('GPU:')}        ${dep.gpu_type} × ${dep.gpu_count}`);
+  console.log(`  ${chalk.bold('Endpoint:')}   ${chalk.cyan(endpointUrl)}`);
+  if (dep.cost_per_hour > 0) console.log(`  ${chalk.bold('Rate:')}       $${dep.cost_per_hour.toFixed(2)}/hr`);
+  console.log(`\n  ${chalk.bold('Receipt:')}    ${chalk.dim(rcptId)}`);
 
   if (endpointReady) {
-    const keySnip = config.apiKey?.slice(0, 8) || 'sk-...';
-    console.log(`  ${chalk.bold('Use with OpenAI SDK:')}`);
+    console.log(`\n  ${chalk.bold('Use with OpenAI SDK:')}`);
     console.log(chalk.dim(`    from openai import OpenAI`));
-    console.log(chalk.dim(`    client = OpenAI(base_url="${endpointUrl}", api_key="${keySnip}...")`));
+    console.log(chalk.dim(`    client = OpenAI(api_key="${config.apiKey?.slice(0, 8) || 'sk-...'}...", base_url="${endpointUrl}")`));
     console.log(chalk.dim(`    resp = client.chat.completions.create(model="${dep.model || model}", messages=[...])`));
-    console.log();
   }
+
+  console.log(`\n  ${chalk.dim(`Stop billing: badgr down ${dep.deployment_id}`)}\n`);
 }

package/src/commands/status.js

@@ -2,20 +2,24 @@ import { listDeployments as localDeployments } from '../store.js';
 import { listDeployments as apiDeployments } from '../api.js';
 
 export async function statusCommand(config, args, chalk) {
+  console.log(chalk.bold('\n📊 GPU Status\n'));
+
   let deployments = [];
 
+  // ── Live data from the backend ────────────────────────────────────────────
   if (config.apiKey) {
     try {
       const data = await apiDeployments(config);
       deployments = data?.deployments ?? [];
     } catch (err) {
-      console.log(chalk.yellow(`\n  Could not reach API: ${err.message}. Showing local state.\n`));
+      console.log(chalk.yellow(`  Could not reach API: ${err.message}. Showing local state.\n`));
       deployments = localDeployments().map(d => ({
         deployment_id: d.id,
         name: d.name,
         workload_type: d.type,
         gpu_type: d.gpu,
         gpu_count: d.count,
+        provider: d.provider,
         status: d.status,
         cost_per_hour: d.costPerHour,
         endpoint_url: d.endpointUrl,
@@ -29,6 +33,7 @@ export async function statusCommand(config, args, chalk) {
       workload_type: d.type,
       gpu_type: d.gpu,
       gpu_count: d.count,
+      provider: d.provider,
       status: d.status,
       cost_per_hour: d.costPerHour,
       endpoint_url: d.endpointUrl,
@@ -36,46 +41,54 @@ export async function statusCommand(config, args, chalk) {
     }));
   }
 
-  const running = deployments.filter(d => d.status === 'running' || d.status === 'provisioning');
-
-  if (running.length === 0) {
-    console.log(chalk.dim('\n  Nothing running.\n'));
-    console.log(chalk.dim('  badgr run python train.py'));
-    console.log(chalk.dim('  badgr serve meta-llama/Llama-3.1-8B-Instruct\n'));
+  if (deployments.length === 0) {
+    console.log(chalk.dim('  No active deployments.'));
+    console.log(chalk.dim('  Run `badgr serve <model> --gpu L40S` to provision one.\n'));
     return;
   }
 
-  console.log(chalk.bold('\nRunning now:\n'));
-  for (const d of running) {
-    const id   = d.deployment_id || d.name;
-    const type = d.workload_type === 'endpoint' ? 'endpoint' : 'job';
-    const gpu  = d.gpu_type || '—';
-    const rate = d.cost_per_hour > 0 ? chalk.yellow(`$${d.cost_per_hour.toFixed(2)}/hr`) : '';
-    const badge = d.status === 'provisioning'
-      ? chalk.yellow('● starting')
-      : chalk.green('● running');
+  const cols = { name: 16, type: 9, gpu: 11, status: 14, price: 9 };
 
-    console.log(`  ${badge}  ${chalk.bold(id)}  ${type}  ${gpu}  ${rate}`);
+  const header =
+    'Name'.padEnd(cols.name) +
+    'Type'.padEnd(cols.type) +
+    'GPU'.padEnd(cols.gpu) +
+    'Status'.padEnd(cols.status) +
+    'Price/hr';
+  console.log('  ' + chalk.bold(header));
+  console.log('  ' + '─'.repeat(Object.values(cols).reduce((a, b) => a + b, 0) + 8));
 
-    if (d.workload_type === 'endpoint' && d.endpoint_url) {
-      console.log(`    ${chalk.dim('URL:')}    ${d.endpoint_url}`);
-    }
-    if (d.model) {
-      console.log(`    ${chalk.dim('Model:')}  ${d.model}`);
-    }
-    console.log();
-  }
+  deployments.forEach(d => {
+    const statusColor = d.status === 'running'
+      ? chalk.green(d.status.padEnd(cols.status))
+      : d.status === 'provisioning'
+        ? chalk.yellow(d.status.padEnd(cols.status))
+        : chalk.dim(d.status.padEnd(cols.status));
+    const price = d.cost_per_hour > 0 ? `$${d.cost_per_hour.toFixed(2)}` : '—';
+    const name = (d.name || d.deployment_id || '').slice(0, cols.name - 1);
+    const gpu = (d.gpu_type || '—').slice(0, cols.gpu - 1).padEnd(cols.gpu);
+    console.log(
+      '  ' +
+      name.padEnd(cols.name) +
+      (d.workload_type || '—').padEnd(cols.type) +
+      gpu +
+      statusColor +
+      price
+    );
+  });
 
-  const billable = running.filter(d => (d.cost_per_hour || 0) > 0);
-  if (billable.length > 0) {
-    const totalPerHr = billable.reduce((s, d) => s + (d.cost_per_hour || 0), 0);
-    console.log(`  ${chalk.bold('Total billing:')} ${chalk.yellow(`$${totalPerHr.toFixed(2)}/hr`)}\n`);
-  }
+  console.log();
 
-  console.log(chalk.bold('Stop billing:\n'));
-  for (const d of running) {
-    const id = d.deployment_id || d.name;
-    console.log(`  ${chalk.cyan(`badgr down ${id}`)}`);
+  // Show endpoint URLs for running endpoint deployments
+  const endpoints = deployments.filter(d => d.workload_type === 'endpoint' && d.status === 'running');
+  if (endpoints.length > 0) {
+    console.log(chalk.bold('  Endpoints\n'));
+    endpoints.forEach(d => {
+      const url = d.endpoint_url || config.baseUrl;
+      console.log(`  ${chalk.cyan(d.name || d.deployment_id)}`);
+      console.log(`    ${chalk.dim('URL:')}    ${url}`);
+      if (d.model) console.log(`    ${chalk.dim('model:')} ${d.model}`);
+    });
+    console.log();
   }
-  console.log();
 }

package/src/commands/up.js

@@ -1,31 +1,37 @@
 import { parseSpec, validateSpec, specLines } from '../spec.js';
+import { getRoutePlan } from '../router.js';
 import { requireApiKey } from '../config.js';
 import { generateDeploymentId, generateReceiptId, addDeployment, addReceipt } from '../store.js';
-import { createDeployment, callApi } from '../api.js';
+import { createDeployment } from '../api.js';
 
-function printLivePlan(suggestions, gpu, chalk) {
-  const { matches = [], alternatives = [] } = suggestions;
+const OVERHEAD_PCT = 0.25;
 
-  console.log(chalk.bold('  Live availability'));
+function printRoutePlan(plan, chalk) {
+  const { lane1, lane2, cheapestRate, costWithOverhead, canonical } = plan;
+
+  console.log(chalk.bold('  Lane 1 — Own GPU Hosts'));
   console.log(`  ${'─'.repeat(40)}`);
-  if (matches.length === 0) {
-    console.log(chalk.yellow(`  No ${gpu} capacity found right now`));
-  } else {
-    const cheapest = matches[0];
-    console.log(`  ${chalk.cyan(gpu)} available — from ${chalk.green('$' + cheapest.price.toFixed(2) + '/hr')}`);
-    console.log(chalk.dim(`  ${matches.length} offer(s) found`));
-  }
+  console.log(chalk.dim(`  ${lane1.description}`));
   console.log();
 
-  if (alternatives.length > 0) {
-    console.log(chalk.bold('  Alternatives if unavailable'));
-    console.log(`  ${'─'.repeat(40)}`);
-    alternatives.slice(0, 3).forEach((a, i) => {
-      const diff = a.diff_desc ? chalk.dim(` — ${a.diff_desc}`) : '';
-      console.log(`  ${i + 1}. ${chalk.cyan(a.gpu)} in ${a.region}  $${a.price.toFixed(2)}/hr${diff}`);
+  console.log(chalk.bold('  Lane 2 — Overflow Providers  (cheapest-first)'));
+  console.log(`  ${'─'.repeat(40)}`);
+  if (lane2.length === 0) {
+    console.log(chalk.yellow(`  No pricing data for ${canonical}`));
+  } else {
+    lane2.forEach((p, i) => {
+      const arrow = i === 0 ? chalk.green(' ← primary') : '';
+      console.log(
+        `  ${String(i + 1)}. ${p.provider.padEnd(12)} ${canonical.padEnd(10)}` +
+        `  $${p.ratePerHour.toFixed(2)}/hr` +
+        `  reliability: ${Math.round(p.reliability * 100)}%${arrow}`
+      );
     });
     console.log();
+    console.log(`  Estimated range: $${cheapestRate.toFixed(2)}–$${lane2[lane2.length - 1].ratePerHour.toFixed(2)}/hr`);
+    console.log(chalk.dim(`  Estimated Badgr price: ~$${costWithOverhead.toFixed(2)}/hr`));
   }
+  console.log();
   console.log(chalk.dim('  Remove --dry-run to provision.'));
   console.log();
 }
@@ -39,27 +45,15 @@ export async function upCommand(config, args, chalk) {
     return;
   }
 
-  // ── Dry-run: show live route plan from backend ───────────────────────────
+  // ── Dry-run: show route plan and exit ─────────────────────────────────────
   if (spec.dryRun) {
     console.log(chalk.bold('\n🔍 Dry Run — Route Plan\n'));
     console.log(chalk.bold('  Spec'));
     console.log(`  ${'─'.repeat(40)}`);
     specLines(spec).forEach(l => console.log(`  ${l}`));
     console.log();
-
-    requireApiKey(config);
-    try {
-      const params = new URLSearchParams({ gpu: spec.gpu, max_price: String(spec.maxPrice ?? 10) });
-      if (spec.region) params.set('region', spec.region);
-      const suggestions = await callApi(`/capacity/suggestions?${params}`, {
-        apiKey: config.apiKey,
-        baseUrl: config.baseUrl,
-      });
-      printLivePlan(suggestions, spec.gpu, chalk);
-    } catch (err) {
-      console.log(chalk.yellow(`  Could not fetch live availability: ${err.message}`));
-      console.log(chalk.dim('  Tip: check `badgr capacity` for live data.\n'));
-    }
+    const plan = getRoutePlan(spec.gpu, spec.count);
+    printRoutePlan(plan, chalk);
     return;
   }
 

package/src/config.js

@@ -6,61 +6,16 @@ export const CONFIG_DIR = join(homedir(), '.badgr');
 export const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
 
 export const DEFAULTS = {
-  baseUrl: 'https://aibadgr.com/v1',
+  baseUrl: 'https://api.badgr.ai/v1',
   defaultModel: 'meta-llama/Llama-3.1-8B-Instruct',
 };
 
-/** URLs that do not resolve or are superseded by aibadgr.com/v1 (nginx) */
-const LEGACY_BASE_URLS = new Set([
-  'https://api.badgr.ai/v1',
-  'https://api.badgr.ai',
-  'http://api.badgr.ai/v1',
-  'http://api.badgr.ai',
-  'https://api.aibadgr.com/v1',
-  'https://api.aibadgr.com',
-  'http://api.aibadgr.com/v1',
-  'http://api.aibadgr.com',
-]);
-
-export function normalizeBaseUrl(url) {
-  if (!url?.trim()) return DEFAULTS.baseUrl;
-  const trimmed = url.trim().replace(/\/+$/, '');
-  if (LEGACY_BASE_URLS.has(trimmed)) return DEFAULTS.baseUrl;
-  return trimmed.endsWith('/v1') ? trimmed : `${trimmed}/v1`;
-}
-
-function applyEnvOverrides(config) {
-  const envBase = process.env.BADGR_API_URL?.trim();
-  if (envBase) config.baseUrl = normalizeBaseUrl(envBase);
-  const envKey = process.env.BADGR_API_KEY?.trim();
-  if (envKey) config.apiKey = envKey;
-  return config;
-}
-
 export function loadConfig(configFile = CONFIG_FILE) {
-  if (!existsSync(configFile)) {
-    return applyEnvOverrides({ ...DEFAULTS });
-  }
+  if (!existsSync(configFile)) return { ...DEFAULTS };
   try {
-    const parsed = JSON.parse(readFileSync(configFile, 'utf8'));
-    const previousBase = parsed.baseUrl;
-    const config = applyEnvOverrides({
-      ...DEFAULTS,
-      ...parsed,
-      baseUrl: normalizeBaseUrl(parsed.baseUrl ?? DEFAULTS.baseUrl),
-    });
-    if (
-      configFile === CONFIG_FILE &&
-      previousBase &&
-      normalizeBaseUrl(previousBase) !== previousBase
-    ) {
-      const merged = { ...parsed, baseUrl: config.baseUrl };
-      mkdirSync(dirname(configFile), { recursive: true });
-      writeFileSync(configFile, JSON.stringify(merged, null, 2));
-    }
-    return config;
+    return { ...DEFAULTS, ...JSON.parse(readFileSync(configFile, 'utf8')) };
   } catch {
-    return applyEnvOverrides({ ...DEFAULTS });
+    return { ...DEFAULTS };
   }
 }