badgr-cli 1.0.6 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "badgr-cli",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Badgr — run or serve GPU workloads from one command",
   "type": "module",
   "bin": {

package/src/api.js

@@ -48,21 +48,28 @@ export async function callApi(path, { method = 'GET', apiKey, baseUrl, body } =
   if (!res.ok) {
     let detail = '';
     let rawBody = '';
+    let errorData = null;
     try {
       rawBody = await res.text();
       dbg('Error response body:', rawBody);
       const json = JSON.parse(rawBody);
+      errorData = json;
       detail = json?.detail ?? json?.message ?? json?.error ?? rawBody;
     } catch {
       detail = rawBody || res.statusText || '';
     }
+    const isCapacityError = errorData?.code === 'NO_CAPACITY_MATCH';
     const hint =
       res.status === 401 ? '\n  Hint: Invalid or missing API key — run: badgr login' :
       res.status === 403 ? '\n  Hint: Access denied — check your API key permissions' :
       res.status === 404 ? `\n  Hint: Endpoint not found — check BADGR_API_URL (currently: ${baseUrl})` :
-      res.status === 502 || res.status === 503 ? '\n  Hint: Server error — no GPU capacity available or backend is down' :
+      (res.status === 502 || res.status === 503) && !isCapacityError
+        ? '\n  Hint: Server error — no GPU capacity available or backend is down' :
       '';
-    throw new Error(`${method} ${path} → HTTP ${res.status}: ${detail}${hint}`);
+    const err = new Error(`${method} ${path} → HTTP ${res.status}: ${detail}${hint}`);
+    err.errorData = errorData;
+    err.httpStatus = res.status;
+    throw err;
   }
   return res.json();
 }

package/src/badgr.js

@@ -10,6 +10,7 @@ import { receiptsCommand } from './commands/receipts.js';
 import { runCommand }      from './commands/run.js';
 import { serveCommand }    from './commands/serve.js';
 import { modelsCommand }   from './commands/models.js';
+import { capacityCommand } from './commands/capacity.js';
 
 const HELP = `
 ${chalk.bold('badgr')} — run or serve GPU workloads from one command
@@ -22,6 +23,7 @@ ${chalk.bold('CORE COMMANDS')}
   ${chalk.cyan('badgr logs <id>')}                     Stream logs for a deployment
   ${chalk.cyan('badgr down <id>')}                     Terminate a deployment (stop billing)
   ${chalk.cyan('badgr receipts [<id>|<n>]')}           Show receipts — pass ID for single, number for list
+  ${chalk.cyan('badgr capacity [--gpu <type>]')}       Check live GPU availability and alternatives
 
 ${chalk.bold('badgr run OPTIONS')}
   --gpu <type>        GPU: RTX_4090, A100, L40S, H100  (default: RTX_4090)
@@ -83,6 +85,7 @@ async function main() {
     case 'down':     return downCommand(config, rest, chalk);
     case 'receipts': return receiptsCommand(config, rest, chalk);
     case 'models':   return modelsCommand(config, chalk);
+    case 'capacity': return capacityCommand(config, rest, chalk);
     // legacy aliases kept for compatibility
     case 'up':       return upCommand(config, rest, chalk);
     case 'config': {

package/src/commands/capacity.js

@@ -0,0 +1,104 @@
+import { requireApiKey } from '../config.js';
+import { callApi } from '../api.js';
+
+/**
+ * badgr capacity                       # check RTX_4090 at default $10/hr cap
+ * badgr capacity --gpu L40S            # check a specific GPU type
+ * badgr capacity --gpu A100 --region EU
+ * badgr capacity --max-price 5
+ *
+ * Internal diagnostic command: shows per-provider availability breakdown.
+ * Provider display names come from the backend — none are hardcoded here.
+ */
+
+function parseCapacityArgs(args) {
+  const flags = {};
+  let i = 0;
+  while (i < args.length) {
+    if (args[i] === '--gpu')       { flags.gpu = args[++i]; i++; continue; }
+    if (args[i] === '--region')    { flags.region = args[++i]; i++; continue; }
+    if (args[i] === '--max-price') { flags.maxPrice = parseFloat(args[++i]); i++; continue; }
+    i++;
+  }
+  return flags;
+}
+
+export async function capacityCommand(config, args, chalk) {
+  const flags = parseCapacityArgs(args);
+  requireApiKey(config);
+
+  const gpu = flags.gpu || 'RTX_4090';
+  const maxPrice = flags.maxPrice ?? 10;
+
+  const params = new URLSearchParams({ gpu, max_price: String(maxPrice) });
+  if (flags.region) params.set('region', flags.region.toUpperCase());
+
+  console.log(chalk.bold(`\n⚡ GPU Capacity Check\n`));
+  console.log(`  ${chalk.bold('GPU:')}       ${gpu}`);
+  if (flags.region) console.log(`  ${chalk.bold('Region:')}    ${flags.region.toUpperCase()}`);
+  console.log(`  ${chalk.bold('Max price:')} $${maxPrice.toFixed(2)}/hr`);
+  console.log();
+
+  let data;
+  try {
+    data = await callApi(`/capacity/suggestions?${params}`, {
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+    });
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ Capacity check failed: ${err.message}\n`));
+    process.exit(1);
+  }
+
+  // Per-provider breakdown
+  const diags = data.diagnostics ?? [];
+  if (diags.length > 0) {
+    console.log(chalk.bold('  Provider breakdown:'));
+    for (const d of diags) {
+      const padded = (d.display_name ?? 'Unknown').padEnd(12);
+      if (d.status === 'no_key') {
+        console.log(`    ${chalk.dim(padded)}  ${chalk.dim('disabled — ' + d.reason)}`);
+      } else if (d.status === 'error') {
+        console.log(`    ${chalk.dim(padded)}  ${chalk.red('error — ' + d.reason)}`);
+      } else if (d.status === 'ok') {
+        const price = d.cheapest_price != null ? chalk.green(`cheapest $${d.cheapest_price.toFixed(2)}/hr`) : '';
+        console.log(`    ${chalk.bold(padded)}  ${d.eligible_count} eligible   ${price}`);
+      } else {
+        const reason = d.reason ? chalk.dim(` — ${d.reason}`) : '';
+        console.log(`    ${chalk.dim(padded)}  0 eligible${reason}`);
+      }
+    }
+    console.log();
+  }
+
+  // Direct matches
+  const matches = data.matches ?? [];
+  if (matches.length > 0) {
+    console.log(chalk.bold('  Available now:'));
+    for (const m of matches) {
+      console.log(`    ${chalk.green('•')} ${m.gpu} in ${m.region}   $${m.price.toFixed(2)}/hr`);
+    }
+    console.log();
+    console.log(chalk.bold('  Run:'));
+    console.log(chalk.cyan(`    badgr run ... --gpu ${gpu}${flags.region ? ' --region ' + flags.region.toUpperCase() : ''}`));
+  } else {
+    console.log(chalk.dim(`  No ${gpu} found under $${maxPrice.toFixed(2)}/hr${flags.region ? ' in ' + flags.region.toUpperCase() : ' globally'}.`));
+  }
+
+  // Alternatives
+  const alternatives = data.alternatives ?? [];
+  if (alternatives.length > 0 && matches.length === 0) {
+    console.log();
+    console.log(chalk.bold('  Alternatives:'));
+    for (const a of alternatives) {
+      console.log(`    ${chalk.dim('•')} ${a.gpu} in ${a.region}   $${a.price.toFixed(2)}/hr`);
+    }
+    console.log();
+    console.log(chalk.bold('  Try:'));
+    for (const a of alternatives) {
+      console.log(chalk.cyan(`    badgr run ... --gpu ${a.gpu}`));
+    }
+  }
+
+  console.log();
+}

package/src/commands/run.js

@@ -113,16 +113,51 @@ export async function runCommand(config, args, chalk) {
         image,
         gpu: gpu.toUpperCase().replace('-', '_'),
         gpu_count: flags.count || 1,
-        region: flags.region || 'US',
+        ...(flags.region ? { region: flags.region.toUpperCase() } : {}),
         max_price_per_hour: flags.maxPrice,
         name: flags.name,
       },
     });
   } catch (err) {
-    console.error(chalk.red(`\n  ✗ Job failed to start: ${err.message}`));
-    console.error(chalk.dim(`\n  Debug: BADGR_DEBUG=1 badgr run … — shows full request/response`));
-    console.error(chalk.dim(`  Config:  badgr config`));
-    console.error(chalk.dim(`  Docs:    badgr --help\n`));
+    const d = err.errorData;
+    if (d?.code === 'NO_CAPACITY_MATCH') {
+      const f = d.filters ?? {};
+      const scope = f.region && f.region !== 'any' ? `in ${f.region}` : 'globally';
+      console.error(chalk.red(`\n  ✗ No ${f.gpu || gpu} found under ${f.max_price || '$10/hr'} ${scope}.\n`));
+
+      const sameGpuElsewhere = Array.isArray(d.same_gpu_other_regions) ? d.same_gpu_other_regions : [];
+      const alternatives = Array.isArray(d.alternatives) ? d.alternatives : [];
+      const cmdPrefix = command ? command.join(' ') : flags.image ? `--image ${flags.image}` : '...';
+
+      if (sameGpuElsewhere.length > 0) {
+        // Requested GPU exists, but not in the specified region.
+        console.error(chalk.dim(`  ${f.gpu} is available in other regions:\n`));
+        console.error(chalk.dim('  Try:'));
+        for (const a of sameGpuElsewhere) {
+          console.error(chalk.cyan(`    badgr run ${cmdPrefix} --gpu ${a.gpu} --region ${a.region}`));
+          console.error(chalk.dim(`      from $${a.price.toFixed(2)}/hr`));
+        }
+      } else if (alternatives.length > 0) {
+        // Global search failed — show what is actually available.
+        console.error(chalk.dim('  Available right now:\n'));
+        for (const a of alternatives) {
+          console.error(chalk.dim(`    • ${a.gpu} in ${a.region} from $${a.price.toFixed(2)}/hr`));
+        }
+        console.error(chalk.dim('\n  Try:'));
+        for (const a of alternatives) {
+          console.error(chalk.cyan(`    badgr run ${cmdPrefix} --gpu ${a.gpu}`));
+        }
+      } else {
+        console.error(chalk.dim('  No alternative GPU capacity found right now.'));
+        console.error(chalk.dim('  Try increasing --max-price or contact support for a manual quote.'));
+      }
+      console.error('');
+    } else {
+      console.error(chalk.red(`\n  ✗ Job failed to start: ${err.message}`));
+      console.error(chalk.dim(`\n  Debug: BADGR_DEBUG=1 badgr run … — shows full request/response`));
+      console.error(chalk.dim(`  Config:  badgr config`));
+      console.error(chalk.dim(`  Docs:    badgr --help\n`));
+    }
     process.exit(1);
   }