badgr-cli 1.0.31 → 1.0.34

package/src/commands/billing.js

@@ -0,0 +1,93 @@
+import { execSync } from 'child_process';
+import { requireApiKey } from '../config.js';
+import { callApi } from '../api.js';
+
+const BILLING_HELP = `
+badgr billing — manage your AI Badgr balance
+
+COMMANDS
+  badgr billing status         Show current balance
+  badgr billing add <amount>   Open checkout to add balance (minimum $10)
+
+EXAMPLES
+  badgr billing status
+  badgr billing add 10
+  badgr billing add 20
+  badgr billing add 50
+`;
+
+function openBrowser(url) {
+  const platform = process.platform;
+  try {
+    if (platform === 'darwin') execSync(`open "${url}"`);
+    else if (platform === 'win32') execSync(`start "" "${url}"`);
+    else execSync(`xdg-open "${url}"`);
+  } catch {
+    // Silently ignore — we print the URL anyway
+  }
+}
+
+async function billingStatus(config, chalk) {
+  requireApiKey(config);
+  try {
+    const apiUrl = config.baseUrl.replace('/v1', '').replace('/api/v1', '');
+    const data = await callApi('/api/me', {
+      apiKey: config.apiKey,
+      baseUrl: apiUrl,
+    });
+    const credits = data.credits ?? 0;
+    const balanceUsd = (credits / 10000).toFixed(2);
+    console.log();
+    console.log(chalk.bold('  Balance'));
+    console.log(`  ${chalk.bold(chalk.blue(`$${balanceUsd}`))}`);
+    console.log();
+    if (credits === 0) {
+      console.log(chalk.yellow('  Balance is $0.00. Add balance before making API calls or running GPU jobs.'));
+      console.log(chalk.dim('  Add balance: badgr billing add 10'));
+      console.log(chalk.dim('  Or visit:    https://aibadgr.com/billing/top-up'));
+    }
+    console.log();
+  } catch (err) {
+    if (err.isPaymentRequired) {
+      console.error(err.message);
+      process.exit(1);
+    }
+    console.error(chalk.red('  Could not fetch balance: ' + err.message));
+    process.exit(1);
+  }
+}
+
+async function billingAdd(config, amount, chalk) {
+  requireApiKey(config);
+  const amountInt = parseInt(amount, 10);
+  if (!amountInt || amountInt < 10) {
+    console.error(chalk.red('  Minimum top-up is $10. Example: badgr billing add 10'));
+    process.exit(1);
+  }
+
+  const url = `https://aibadgr.com/dashboard#billing`;
+  console.log();
+  console.log(chalk.bold(`  Opening dashboard billing to add $${amountInt}...`));
+  console.log();
+  console.log(`  ${chalk.dim(url)}`);
+  console.log();
+  openBrowser(url);
+  console.log(chalk.dim('  Complete payment in your browser, then rerun your command.'));
+  console.log();
+}
+
+export async function billingCommand(config, args, chalk) {
+  const [sub, ...rest] = args;
+
+  if (!sub || sub === '--help' || sub === '-h') {
+    console.log(BILLING_HELP);
+    return;
+  }
+
+  if (sub === 'status') return billingStatus(config, chalk);
+  if (sub === 'add') return billingAdd(config, rest[0], chalk);
+
+  console.error(chalk.red(`  Unknown billing command: ${sub}`));
+  console.log(chalk.dim('  Run: badgr billing --help'));
+  process.exit(1);
+}

package/src/commands/capacity.js

@@ -0,0 +1,111 @@
+import { requireApiKey } from '../config.js';
+import { callApi } from '../api.js';
+
+/**
+ * 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;
+  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 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(`\nCapacity: ${gpu}\n`));
+  process.stdout.write(chalk.dim('  Checking...\n'));
+
+  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);
+  }
+
+  const matches = data.matches ?? [];
+  if (matches.length > 0) {
+    console.log(chalk.bold('\n  Available now:\n'));
+    for (const m of matches) {
+      console.log(`    ${chalk.green('●')} ${m.gpu} in ${m.region}   ${chalk.green('$' + m.price.toFixed(2) + '/hr')}`);
+    }
+    console.log();
+    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 {
+    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`));
+
+    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'));
+    }
+  }
+}

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,20 +1,36 @@
 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:',
     validate: v => v.trim() ? true : 'API key is required',
   });
 
-  const baseUrl = await input({
-    message: 'API base URL:',
-    default: 'https://api.badgr.ai/v1',
+  const config = saveConfigFn({
+    apiKey: apiKey.trim(),
+    baseUrl: DEFAULTS.baseUrl,
   });
 
-  const config = saveConfigFn({ apiKey: apiKey.trim(), baseUrl: baseUrl.trim() });
-  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;
 }

package/src/commands/logs.js

@@ -1,6 +1,12 @@
 import { findDeployment, listDeployments } from '../store.js';
 import { requireApiKey } from '../config.js';
-import { getDeploymentLogs } from '../api.js';
+import { getDeploymentLogs, callApi } from '../api.js';
+
+const TERMINAL_STATUSES = new Set(['succeeded', 'completed', 'failed', 'stopped', 'terminated']);
+const FOLLOW_POLL_MS = 3000;
+
+// Lines that carry structured metadata shown elsewhere (status bar in `badgr run`).
+const LOG_META_RE = /^\[dep-[^\]]+\] (status|gpu|region|endpoint|cost|receipt|provider_status|uptime)=/;
 
 export async function logsCommand(config, args, chalk) {
   const idOrName = args.find(a => !a.startsWith('--'));
@@ -26,13 +32,18 @@ export async function logsCommand(config, args, chalk) {
 
   console.log(chalk.bold(`\n📋 Logs: ${localDep?.name ?? deploymentId}\n`));
 
+  // Fetch and print initial batch of logs.
+  const seen = new Set();
   try {
     const data = await getDeploymentLogs(config, deploymentId);
     const lines = data?.logs ?? [];
-    if (lines.length === 0) {
+    if (lines.length === 0 && !follow) {
       console.log(chalk.dim('  No log lines available yet.\n'));
     } else {
-      lines.forEach(l => console.log(`  ${chalk.dim(l)}`));
+      for (const line of lines) {
+        seen.add(line);
+        if (!LOG_META_RE.test(line)) console.log(`  ${chalk.dim(line)}`);
+      }
     }
   } catch (err) {
     console.log(chalk.yellow(`  Could not fetch logs: ${err.message}`));
@@ -40,10 +51,51 @@ export async function logsCommand(config, args, chalk) {
       console.log(chalk.dim(`\n  GPU: ${localDep.gpu}  Type: ${localDep.type}`));
       console.log(chalk.dim(`  Endpoint: ${localDep.endpointUrl}`));
     }
+    if (!follow) { console.log(); return; }
   }
 
-  if (follow) {
-    console.log(chalk.yellow('\n  --follow: live log streaming not yet supported. Poll with `badgr logs`.\n'));
+  if (!follow) { console.log(); return; }
+
+  // --follow: poll until the deployment reaches a terminal state.
+  console.log(chalk.dim('  (following — Ctrl+C to stop)\n'));
+
+  let stopping = false;
+  process.once('SIGINT', () => { stopping = true; });
+
+  while (!stopping) {
+    await new Promise(r => setTimeout(r, FOLLOW_POLL_MS));
+    if (stopping) break;
+
+    let status = null;
+    try {
+      const dep = await callApi(`/deployments/${deploymentId}`, {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+      });
+      status = dep?.status ?? null;
+    } catch {
+      // network blip — keep following
+    }
+
+    try {
+      const data = await getDeploymentLogs(config, deploymentId);
+      for (const line of (data?.logs ?? [])) {
+        if (seen.has(line)) continue;
+        seen.add(line);
+        if (!LOG_META_RE.test(line)) {
+          const isErr = /^error\b/i.test(line) || /Error response from daemon/i.test(line);
+          console.log(`  ${isErr ? chalk.red(line) : chalk.dim(line)}`);
+        }
+      }
+    } catch {
+      // logs endpoint temporarily unavailable
+    }
+
+    if (status && TERMINAL_STATUSES.has(status)) {
+      console.log(chalk.dim(`\n  Job ${status}. No more logs.\n`));
+      break;
+    }
   }
+
   console.log();
 }

package/src/commands/models.js

@@ -1,19 +1,38 @@
-import { listModels } from '../api.js';
+import { listModels, callApi } from '../api.js';
 import { listAll } from '../router.js';
 
 export async function modelsCommand(config, chalk) {
-  const gpus = listAll();
-
   console.log(chalk.bold('\n📦 GPU Options (cheapest first)\n'));
+
+  let gpus = null;
+  if (config.apiKey) {
+    try {
+      const data = await callApi('/gpus', { apiKey: config.apiKey, baseUrl: config.baseUrl });
+      if (data?.gpus?.length) {
+        gpus = data.gpus.map(g => ({
+          id:          g.id,
+          name:        g.name,
+          vramGb:      g.vram_gb,
+          ratePerHour: g.rate_per_hour,
+        })).sort((a, b) => a.ratePerHour - b.ratePerHour);
+      }
+    } catch {
+      // fallback to local catalog on error
+    }
+  }
+
+  if (!gpus) gpus = listAll();
+
   console.log(
-    `  ${'ID'.padEnd(14)}  ${'Name'.padEnd(24)}  ${'VRAM'.padEnd(8)}  Rate/hr`
+    `  ${'ID'.padEnd(14)}  ${'Name'.padEnd(24)}  ${'VRAM'.padEnd(8)}  Rate/hr (indicative)`
   );
-  console.log(`  ${'─'.repeat(58)}`);
+  console.log(`  ${'─'.repeat(68)}`);
   gpus.forEach(g => {
     console.log(
-      `  ${chalk.cyan(g.id.padEnd(14))}  ${g.name.padEnd(24)}  ${`${g.vramGb}GB`.padEnd(8)}  $${g.ratePerHour.toFixed(2)}`
+      `  ${chalk.cyan(g.id.padEnd(14))}  ${g.name.padEnd(24)}  ${`${g.vramGb}GB`.padEnd(8)}  ~$${g.ratePerHour.toFixed(2)}`
     );
   });
+  console.log(chalk.dim('  Actual billing is set at job start — use `badgr run` to see live rates.'));
 
   console.log(chalk.bold('\n🤖 LLM Models\n'));
   if (!config.apiKey) {

package/src/commands/receipts.js

@@ -5,19 +5,38 @@ function fmtMs(ms) {
   return ms >= 1000 ? `${(ms / 1000).toFixed(1)}s` : `${ms}ms`;
 }
 
+function fmtRuntime(s) {
+  if (s < 60) return `${s}s`;
+  return `${Math.floor(s / 60)}m ${s % 60}s`;
+}
+
 function printReceipt(r, chalk) {
   const id     = r.receiptId ?? r.request_id ?? r.id ?? '—';
   const ts     = r.createdAt ?? r.created_at ?? '—';
-  const cost   = r.route?.ratePerHour ?? r.cost_usd ?? 0;
-  const prov   = r.route?.provider ?? r.provider ?? r.model_provider ?? '—';
-  const lat    = r.latencyMs ?? r.latency_ms;
   const action = r.action ?? r.endpoint ?? '—';
+  const lat    = r.latencyMs ?? r.latency_ms;
 
   console.log(`  ${chalk.cyan(id)}`);
   console.log(`    ${chalk.bold('action:')}   ${action}`);
+
+  // GPU job fields (from badgr run / badgr down)
+  if (r.gpu)            console.log(`    ${chalk.bold('gpu:')}      ${r.gpu}`);
+  if (r.runtimeSeconds) console.log(`    ${chalk.bold('runtime:')}  ${fmtRuntime(r.runtimeSeconds)}`);
+  if (r.finalCost)      console.log(`    ${chalk.bold('cost:')}     $${r.finalCost.toFixed(4)}`);
+  else if (r.cost_usd)  console.log(`    ${chalk.bold('cost:')}     $${r.cost_usd.toFixed(4)}`);
+  if (r.exitCode !== undefined && r.exitCode !== null) {
+    console.log(`    ${chalk.bold('exit:')}     ${r.exitCode !== 0 ? chalk.red(r.exitCode) : chalk.green(r.exitCode)}`);
+  }
+
+  // API inference receipt fields
   if (lat !== undefined) console.log(`    ${chalk.bold('latency:')}  ${fmtMs(lat)}`);
-  if (cost) console.log(`    ${chalk.bold('cost:')}     $${typeof cost === 'number' ? cost.toFixed(4) : cost}/hr`);
   if (r.retries !== undefined) console.log(`    ${chalk.bold('retries:')}  ${r.retries}`);
+  if (r.route?.ratePerHour) console.log(`    ${chalk.bold('rate:')}     $${r.route.ratePerHour.toFixed(4)}/hr`);
+
+  if (r.failureCategory ?? r.failure_category ?? r.failure_reason) {
+    const cat = r.failureCategory ?? r.failure_category ?? r.failure_reason;
+    console.log(`    ${chalk.bold('failure:')}  ${chalk.red(cat)}`);
+  }
   if (r.status) console.log(`    ${chalk.bold('status:')}   ${r.status}`);
   console.log(`    ${chalk.dim(ts)}`);
   console.log();