badgr-cli 1.0.12 → 1.0.15

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "badgr-cli",
-  "version": "1.0.12",
-  "description": "Badgr — run or serve GPU workloads from one command",
+  "version": "1.0.15",
+  "description": "Badgr, run or serve GPU workloads from one command",
   "type": "module",
   "bin": {
-    "badgr": "./src/badgr.js"
+    "badgr": "src/badgr.js"
   },
   "scripts": {
     "start": "node src/badgr.js",
@@ -21,6 +21,14 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "keywords": ["gpu", "cli", "ai", "compute", "modal", "gateway", "openai"],
+  "keywords": [
+    "gpu",
+    "cli",
+    "ai",
+    "compute",
+    "modal",
+    "gateway",
+    "openai"
+  ],
   "license": "MIT"
 }

package/src/badgr.js

@@ -15,64 +15,60 @@ import { capacityCommand } from './commands/capacity.js';
 const HELP = `
 ${chalk.bold('badgr')} — run or serve GPU workloads from one command
 
-${chalk.bold('CORE COMMANDS')}
-  ${chalk.cyan('badgr login')}                         Authenticate (save API key to ~/.badgr/config.json)
-  ${chalk.cyan('badgr run <cmd...> --gpu <type>')}     Run a one-off GPU job
-  ${chalk.cyan('badgr serve <model> --gpu <type>')}    Serve a model (OpenAI-compatible endpoint)
-  ${chalk.cyan('badgr status')}                        Show active deployments + endpoint URLs
-  ${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)
-  --image <image>           Docker image (default: python:3.11-slim)
-  --count <n>               GPU count (default: 1)
-  --region US|EU|AU         Region preference (default: US)
-  --max-price <$/hr>        Hard spend cap per GPU-hour
-  --name <name>             Job name (auto-generated if omitted)
-  --fallback closest|cheapest  If requested GPU is unavailable, interactively pick the
-                            closest (default) or cheapest alternative
-  --no-fallback             Exit immediately when requested GPU is unavailable
-  --max-runtime <minutes>   Auto-teardown job after N minutes (prevents runaway billing)
-  --max-cost <$>            Auto-teardown when total spend reaches this amount
-
-${chalk.bold('badgr serve OPTIONS')}
-  --gpu <type>        GPU: L40S, A100, H100, RTX_4090  (default: L40S)
-  --count <n>         GPU count (default: 1)
-  --region US|EU|AU   Region preference (default: US)
-  --max-price <$/hr>  Hard spend cap per GPU-hour
-  --name <name>       Deployment name (auto-generated if omitted)
+${chalk.bold('COMMANDS')}
+  ${chalk.cyan('badgr login')}                  Authenticate with your API key
+  ${chalk.cyan('badgr run <command>')}          Run a one-off GPU job
+  ${chalk.cyan('badgr serve <model>')}          Serve a model with an OpenAI-compatible endpoint
+  ${chalk.cyan('badgr status')}                 Show what's running and what's billing
+  ${chalk.cyan('badgr logs <id>')}              Stream logs for a running job or endpoint
+  ${chalk.cyan('badgr down <id>')}              Stop a deployment and end billing
+  ${chalk.cyan('badgr receipts')}               Show cost history
+  ${chalk.cyan('badgr capacity')}               Check what GPU capacity is available right now
 
 ${chalk.bold('EXAMPLES')}
-  badgr login
+  ${chalk.dim('# Simplest — Badgr picks the GPU:')}
+  badgr run python train.py
+  badgr serve meta-llama/Llama-3.1-8B-Instruct
+
+  ${chalk.dim('# Pin a specific GPU:')}
   badgr run python train.py --gpu A100
-  badgr run python train.py --gpu A100 --fallback closest
-  badgr run python train.py --gpu A100 --fallback cheapest
-  badgr run python train.py --gpu A100 --no-fallback
-  badgr run --image my/image:latest --gpu L40S
   badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S
-  badgr serve mistralai/Mistral-7B-v0.1 --gpu RTX_4090
+
+  ${chalk.dim('# Add safety caps:')}
+  badgr run python train.py --max-runtime 60 --max-cost 5
+
+  ${chalk.dim('# Manage a running deployment:')}
   badgr status
-  badgr logs dep_abc123
-  badgr down dep_abc123
-  badgr receipts
-  badgr receipts dep_abc123
+  badgr logs dep-abc123
+  badgr down dep-abc123
+  badgr receipts dep-abc123
 
-${chalk.bold('OPENAI-COMPATIBLE SERVING')}
-  ${chalk.dim('After `badgr serve`, point any OpenAI client at the returned URL:')}
-  ${chalk.dim('  client = OpenAI(api_key="sk-...", base_url="https://aibadgr.com/v1")')}
-  ${chalk.dim('  client.chat.completions.create(model="dep_xxx", messages=[...])')}
+${chalk.bold('badgr run OPTIONS')}
+  --gpu <type>           GPU type (default: auto — Badgr picks cheapest available)
+  --image <image>        Docker image (default: python:3.11-slim)
+  --count <n>            Number of GPUs (default: 1)
+  --region US|EU|AU      Region preference
+  --max-price <$/hr>     Hard spend cap per GPU-hour
+  --max-runtime <min>    Auto-stop after N minutes (recommended)
+  --max-cost <$>         Auto-stop when spend reaches this amount
+  --detach               Return immediately, don't stream logs
+
+${chalk.bold('badgr serve OPTIONS')}
+  --gpu <type>           GPU type (default: auto — inferred from model size)
+  --count <n>            Number of GPUs (default: 1)
+  --region US|EU|AU      Region preference
+  --max-price <$/hr>     Hard spend cap per GPU-hour
+  --no-wait              Skip endpoint health check
 
-${chalk.bold('ROUTING')}
-  ${chalk.dim('Badgr automatically selects best available GPU capacity for your request.')}
+${chalk.bold('AFTER SERVING')}
+  ${chalk.dim('Point any OpenAI client at the returned URL:')}
+  ${chalk.dim('  from openai import OpenAI')}
+  ${chalk.dim('  client = OpenAI(base_url="<endpoint url>", api_key="<your key>")')}
+  ${chalk.dim('  client.chat.completions.create(model="<model>", messages=[...])')}
 
-${chalk.bold('DEBUGGING')}
-  ${chalk.dim('Set BADGR_DEBUG=1 to print the full URL, API key prefix, request body, and response status:')}
-  ${chalk.dim('  BADGR_DEBUG=1 badgr run python train.py --gpu A100')}
-  ${chalk.dim('  BADGR_DEBUG=1 badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S')}
-  ${chalk.dim('  badgr config                  # show current baseUrl and key')}
+${chalk.bold('DEBUG')}
+  ${chalk.dim('BADGR_DEBUG=1 badgr run python train.py   # full request/response trace')}
+  ${chalk.dim('badgr config                              # show current API config')}
 `;
 
 async function main() {

package/src/commands/capacity.js

@@ -2,15 +2,9 @@ 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.
+ * badgr capacity              # show what's available right now (auto)
+ * badgr capacity --gpu A100   # check a specific GPU type
  */
-
 function parseCapacityArgs(args) {
   const flags = {};
   let i = 0;
@@ -27,17 +21,50 @@ export async function capacityCommand(config, args, chalk) {
   const flags = parseCapacityArgs(args);
   requireApiKey(config);
 
-  const gpu = flags.gpu || 'RTX_4090';
   const maxPrice = flags.maxPrice ?? 10;
 
+  // No --gpu: show cheapest runnable GPU across all types
+  if (!flags.gpu) {
+    console.log(chalk.bold('\nAvailable GPU capacity\n'));
+    process.stdout.write(chalk.dim('  Checking availability...\n'));
+
+    let data;
+    try {
+      const params = new URLSearchParams({ max_price: String(maxPrice) });
+      if (flags.region) params.set('region', flags.region.toUpperCase());
+      data = await callApi(`/capacity/auto?${params}`, {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+      });
+    } catch (err) {
+      if (err.errorData?.code === 'NO_CAPACITY_MATCH') {
+        console.log(chalk.dim('\n  No GPU capacity available right now.\n'));
+        console.log(chalk.dim('  Try again in a few minutes, or check a specific GPU with --gpu <type>.\n'));
+        return;
+      }
+      console.error(chalk.red(`\n  ✗ Capacity check failed: ${err.message}\n`));
+      process.exit(1);
+    }
+
+    console.log();
+    console.log(`  ${chalk.bold('Cheapest available:')} ${chalk.cyan(data.gpu)} in ${data.region}   ${chalk.green('$' + data.price.toFixed(2) + '/hr')}`);
+    console.log();
+    console.log(`  ${chalk.bold('Run now:')}`);
+    console.log(chalk.cyan(`    badgr run python train.py`));
+    console.log(chalk.cyan(`    badgr serve meta-llama/Llama-3.1-8B-Instruct`));
+    console.log();
+    console.log(chalk.dim(`  Use badgr capacity --gpu A100 to check a specific GPU type.`));
+    console.log();
+    return;
+  }
+
+  // --gpu specified: show availability for that type
+  const gpu = flags.gpu.toUpperCase().replace('-', '_');
   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();
+  console.log(chalk.bold(`\nCapacity: ${gpu}\n`));
+  process.stdout.write(chalk.dim('  Checking...\n'));
 
   let data;
   try {
@@ -50,55 +77,35 @@ export async function capacityCommand(config, args, chalk) {
     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:'));
+    console.log(chalk.bold('\n  Available now:\n'));
     for (const m of matches) {
-      console.log(`    ${chalk.green('•')} ${m.gpu} in ${m.region}   $${m.price.toFixed(2)}/hr`);
+      console.log(`    ${chalk.green('●')} ${m.gpu} in ${m.region}   ${chalk.green('$' + 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() : ''}`));
+    const regionFlag = flags.region ? ` --region ${flags.region.toUpperCase()}` : '';
+    console.log(`  ${chalk.bold('Run:')}`);
+    console.log(chalk.cyan(`    badgr run python train.py --gpu ${gpu}${regionFlag}`));
+    console.log();
   } else {
-    console.log(chalk.dim(`  No ${gpu} found under $${maxPrice.toFixed(2)}/hr${flags.region ? ' in ' + flags.region.toUpperCase() : ' globally'}.`));
-  }
+    const regionLabel = flags.region ? ` in ${flags.region.toUpperCase()}` : '';
+    console.log(chalk.dim(`\n  No ${gpu} available right now under $${maxPrice.toFixed(2)}/hr${regionLabel}.\n`));
 
-  // 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}`));
+    const alternatives = data.alternatives ?? [];
+    if (alternatives.length > 0) {
+      console.log(chalk.bold('  Available alternatives:\n'));
+      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.slice(0, 3)) {
+        console.log(chalk.cyan(`    badgr run python train.py --gpu ${a.gpu}`));
+      }
+      console.log();
+    } else {
+      console.log(chalk.dim('  No alternatives found. Try `badgr capacity` to see global availability.\n'));
     }
   }
-
-  console.log();
 }

package/src/commands/down.js

@@ -12,43 +12,46 @@ export async function downCommand(config, args, chalk) {
 
   requireApiKey(config);
 
-  const localDep = findDeployment(idOrName);
-
-  // Resolve the deployment ID to send to the backend
+  const localDep     = findDeployment(idOrName);
   const deploymentId = localDep?.id ?? idOrName;
 
-  console.log(chalk.dim(`  Terminating ${deploymentId}...`));
+  process.stdout.write(chalk.dim(`  Stopping ${deploymentId}...`));
 
   let dep;
   try {
     dep = await terminateDeployment(config, deploymentId);
   } catch (err) {
-    console.error(chalk.red(`\n  ✗ Terminate failed: ${err.message}\n`));
+    process.stdout.write('\n');
+    console.error(chalk.red(`\n  ✗ Could not stop deployment: ${err.message}\n`));
     return;
   }
 
+  process.stdout.write('\n');
+
+  // Compute final cost from the deployment timestamps
+  const stoppedAt   = dep.stopped_at  ?? (Date.now() / 1000);
+  const startedAt   = dep.started_at  ?? stoppedAt;
+  const runtimeMin  = Math.round((stoppedAt - startedAt) / 60);
+  const runtimeHr   = (stoppedAt - startedAt) / 3600;
+  const finalCost   = (dep.cost_per_hour || 0) * runtimeHr;
+
   const rcptId = generateReceiptId();
   addReceipt({
-    receiptId:    rcptId,
-    action:       'badgr down',
-    deploymentId: dep.deployment_id,
-    name:         dep.name,
-    provider:     dep.provider,
-    gpu:          dep.gpu_type,
-    latencyMs:    0,
-    status:       'terminated',
-    createdAt:    new Date().toISOString(),
+    receiptId:      rcptId,
+    action:         'badgr down',
+    deploymentId:   dep.deployment_id,
+    gpu:            dep.gpu_type,
+    runtimeSeconds: Math.round(stoppedAt - startedAt),
+    finalCost,
+    status:         'terminated',
+    createdAt:      new Date().toISOString(),
   });
 
-  // Remove from local store
   removeDeployment(idOrName);
 
-  console.log(chalk.green(`\n✓ Deployment stopped: ${dep.name}\n`));
-  console.log(`  ${chalk.bold('ID:')}        ${dep.deployment_id}`);
-  console.log(`  ${chalk.bold('GPU:')}       ${dep.gpu_type} × ${dep.gpu_count}`);
-  if (dep.started_at) {
-    const uptime = Math.round((Date.now() / 1000 - dep.started_at) / 60);
-    console.log(`  ${chalk.bold('Uptime:')}    ${uptime} min`);
-  }
-  console.log(`\n  ${chalk.bold('Receipt ID:')} ${chalk.dim(rcptId)}\n`);
+  console.log(chalk.green('\n✓ Stopped'));
+  console.log(chalk.green('  Billing ended\n'));
+  console.log(`  ${chalk.bold('Runtime:')}    ${runtimeMin}m`);
+  if (finalCost > 0) console.log(`  ${chalk.bold('Final cost:')} $${finalCost.toFixed(4)}`);
+  console.log(`  ${chalk.bold('Receipt:')}    ${chalk.dim(rcptId)}\n`);
 }

package/src/commands/login.js

@@ -1,8 +1,9 @@
 import { input } from '@inquirer/prompts';
 import { DEFAULTS } from '../config.js';
+import { callApi } from '../api.js';
 
 export async function loginCommand(chalk, saveConfigFn) {
-  console.log(chalk.bold('\n🔑  Badgr Login\n'));
+  console.log(chalk.bold('\nBadgr Login\n'));
 
   const apiKey = await input({
     message: 'Enter your Badgr API key:',
@@ -13,7 +14,23 @@ export async function loginCommand(chalk, saveConfigFn) {
     apiKey: apiKey.trim(),
     baseUrl: DEFAULTS.baseUrl,
   });
-  console.log(chalk.green('\n✓ Logged in — config saved to ~/.badgr/config.json\n'));
-  console.log(chalk.dim(`  Base URL: ${config.baseUrl}\n`));
+
+  console.log(chalk.green('\n✓ Logged in'));
+  console.log(chalk.dim(`  Config saved to ~/.badgr/config.json`));
+
+  // Verify the key works against the live API
+  try {
+    await callApi('/models', { apiKey: config.apiKey, baseUrl: config.baseUrl });
+    console.log(chalk.green('✓ API reachable'));
+    console.log(chalk.green('✓ API key valid\n'));
+  } catch (err) {
+    if (err.httpStatus === 401 || err.httpStatus === 403) {
+      console.log(chalk.yellow('⚠ API key may be invalid — double-check and run badgr login again\n'));
+    } else {
+      console.log(chalk.yellow('⚠ Could not reach the API right now — check your internet connection\n'));
+    }
+  }
+
+  console.log(chalk.dim(`  Run ${chalk.cyan('badgr run python train.py')} to launch your first job.\n`));
   return config;
 }