badgr-cli 1.0.29 → 1.0.31

package/src/commands/serve.js

@@ -1,18 +1,13 @@
-import readline from 'readline';
 import { requireApiKey } from '../config.js';
 import { callApi } from '../api.js';
-import { addDeployment, addReceipt, updateReceipt, generateReceiptId } from '../store.js';
-
-function askConfirm(prompt) {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise(resolve => rl.question(prompt, ans => { rl.close(); resolve(ans.trim()); }));
-}
+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 = {};
@@ -22,7 +17,6 @@ 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; }
@@ -32,26 +26,24 @@ export function parseServeArgs(args) {
   return { model, flags };
 }
 
-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));
   }
@@ -63,42 +55,20 @@ 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';
 
-  // Tier 1 = managed routing (default). Tier 2 = marketplace routing, opt-in via --tier 2.
-  const effectiveTier = (flags.tier === '2' || flags.tier === 'tier2' || flags.tier === 'tier-2')
-    ? '2'
-    : (flags.tier || '1');
-
-  console.log(chalk.bold('\nServing model\n'));
+  console.log(chalk.bold('\n🚀 Serving model\n'));
   console.log(`  ${chalk.bold('Model:')}  ${model}`);
-  console.log(`  ${chalk.bold('GPU:')}    ${gpuLabel}`);
-  if (effectiveTier === '2') console.log(`  ${chalk.dim('(tier 2 — marketplace routing)')}`);
+  console.log(`  ${chalk.bold('GPU:')}    ${gpu}`);
   console.log();
-  process.stdout.write(chalk.dim('  Finding reliable capacity...\n'));
-
-  const effectiveRegion = flags.region ? flags.region.toUpperCase() : undefined;
-
-  function buildBody(gpuOverride, regionOverride) {
-    return {
-      model,
-      gpu: gpuOverride || gpu,
-      gpu_count: flags.count || 1,
-      ...(regionOverride || effectiveRegion ? { region: regionOverride || effectiveRegion } : {}),
-      max_price_per_hour: flags.maxPrice,
-      name: flags.name,
-      tier: effectiveTier,
-    };
-  }
+  console.log(chalk.dim('  Finding best available GPU capacity...'));
 
   let dep;
   try {
@@ -106,88 +76,21 @@ export async function serveCommand(config, args, chalk) {
       method: 'POST',
       apiKey: config.apiKey,
       baseUrl: config.baseUrl,
-      body: buildBody(),
+      body: {
+        model,
+        gpu: gpu.toUpperCase().replace('-', '_'),
+        gpu_count: flags.count || 1,
+        region: flags.region || 'US',
+        max_price_per_hour: flags.maxPrice,
+        name: flags.name,
+      },
     });
   } catch (err) {
-    const d = err.errorData;
-    if (d?.code === 'NO_CAPACITY_MATCH') {
-      if (effectiveTier === '2') {
-        console.error(chalk.red('\n  ✗ No GPU capacity available right now on any provider.\n'));
-        console.error(chalk.dim('  Run `badgr capacity` to see alternatives, or try again shortly.'));
-        process.exit(1);
-      }
-
-      // Tier 1 out of capacity — offer tier 2 marketplace routing.
-      if (process.stdin.isTTY) {
-        const answer = await askConfirm(
-          `\n  No tier 1 capacity available. Try tier 2 marketplace routing? [${chalk.bold('Enter')}/${chalk.bold('q')}]: `
-        );
-        if (answer.toLowerCase() === 'q') {
-          console.log(chalk.dim('\n  Cancelled.\n'));
-          process.exit(0);
-        }
-      } else {
-        console.log(chalk.dim('\n  No tier 1 capacity — trying tier 2 marketplace routing...\n'));
-      }
-
-      console.log(chalk.dim('  Searching tier 2 capacity...'));
-      try {
-        dep = await callApi('/serve', {
-          method: 'POST',
-          apiKey: config.apiKey,
-          baseUrl: config.baseUrl,
-          body: { ...buildBody(), tier: '2' },
-        });
-      } catch (err2) {
-        const d2 = err2.errorData;
-        if (d2?.code === 'NO_CAPACITY_MATCH') {
-          console.error(chalk.red('\n  ✗ No GPU capacity available right now on any provider.\n'));
-          console.error(chalk.dim('  Run `badgr capacity` to see alternatives, or try again shortly.'));
-        } else if (d2?.code === 'PROVISIONING_FAILED' || d2?.code === 'PROVIDER_ADAPTER_ERROR') {
-          console.error(chalk.red(`\n  ✗ Budget provider found capacity but could not start the endpoint. Please try again.\n`));
-          console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr serve … for a full trace.\n`));
-        } else {
-          console.error(chalk.red(`\n  ✗ Could not start endpoint on tier 2: ${err2.message}\n`));
-          console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr serve … for a full trace.\n`));
-        }
-        process.exit(1);
-      }
-    } else if (d?.code === 'PROVISIONING_FAILED' || d?.code === 'PROVIDER_ADAPTER_ERROR') {
-      if (d?.low_cost_provider_failed) {
-        console.error(chalk.red(`\n  ✗ Tier 2 unavailable. Tier 1 also unavailable. Try again shortly.\n`));
-      } else {
-        console.error(chalk.red(`\n  ✗ Badgr found capacity but could not start the endpoint. Please try again.\n`));
-      }
-      console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr serve … for a full trace.\n`));
-      process.exit(1);
-    } else {
-      const failRcptId = generateReceiptId();
-      addReceipt({
-        receiptId:   failRcptId,
-        action:      'badgr serve',
-        model,
-        gpu: gpuLabel,
-        status:      'failed',
-        failureType: 'infrastructure',
-        createdAt:   new Date().toISOString(),
-      });
-      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`));
-      return;
-    }
-  }
-
-  if (dep.provider_fallback_note === 'tier2_failed_using_tier1') {
-    console.log(chalk.yellow('  ℹ Tier 2 unavailable. Running on Tier 1 instead.\n'));
+    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,
@@ -195,6 +98,7 @@ 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,
@@ -207,6 +111,7 @@ export async function serveCommand(config, args, chalk) {
     receiptId:    rcptId,
     action:       'badgr serve',
     deploymentId: dep.deployment_id,
+    provider:     dep.provider,
     gpu:          dep.gpu_type,
     status:       dep.status,
     createdAt:    new Date().toISOString(),
@@ -214,41 +119,41 @@ export async function serveCommand(config, args, chalk) {
 
   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();
   }
 
-  console.log(`  ${chalk.bold('Base URL:')}   ${chalk.cyan(endpointUrl)}`);
+  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}`);
-  if (dep.tier) console.log(`  ${chalk.bold('Tier:')}       ${dep.tier}`);
+  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(`  ${chalk.bold('Logs:')}       ${chalk.dim(`badgr logs ${dep.deployment_id}`)}`);
-  console.log(`  ${chalk.bold('Stop billing:')} ${chalk.dim(`badgr down ${dep.deployment_id}`)}`);
-  console.log();
+  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 };
   }
 }