badgr-cli 1.0.31 → 1.0.34

package/src/commands/serve.js

@@ -1,13 +1,16 @@
 import { requireApiKey } from '../config.js';
 import { callApi } from '../api.js';
-import { addDeployment, addReceipt, generateReceiptId } from '../store.js';
+import { addDeployment, addReceipt, updateReceipt, generateReceiptId } from '../store.js';
+import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
+import { formatCliError } from '../errors.js';
 
 /**
+ * badgr serve meta-llama/Llama-3.1-8B-Instruct
  * badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S
+ * badgr serve BAAI/bge-large-en-v1.5 --task embed
+ * badgr serve --image ghcr.io/my-org/diffusers-api:latest --gpu L40S --env MODEL_ID=flux
  *
- * 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>`.
+ * GPU defaults to "AUTO" — backend infers from model size.
  */
 export function parseServeArgs(args) {
   const flags = {};
@@ -15,82 +18,272 @@ export function parseServeArgs(args) {
   let i = 0;
   while (i < args.length) {
     if (args[i] === '--gpu')        { flags.gpu = args[++i]; i++; continue; }
+    if (args[i] === '--image')      { flags.image = args[++i]; i++; continue; }
+    if (args[i] === '--task')       { flags.task = 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] === '--no-wait')               { flags.noWait = true; i++; continue; }
+    if (args[i] === '--max-cost')              { flags.maxCost = parseFloat(args[++i]); i++; continue; }
+    if (args[i] === '--health-path')           { flags.healthPath = args[++i]; i++; continue; }
+    if (args[i] === '--check-nodes')           { flags.checkNodes = args[++i]; i++; continue; }
+    // All three aliases map to noMarketplaceFallback
+    if (args[i] === '--no-fallback' ||
+        args[i] === '--strict-capacity' ||
+        args[i] === '--no-expanded-search') { flags.noMarketplaceFallback = true; i++; continue; }
+    if (args[i] === '--env') {
+      const kv = args[++i]; i++;
+      if (!flags.env) flags.env = [];
+      flags.env.push(kv);
+      continue;
+    }
     positional.push(args[i++]);
   }
   const model = positional[0] || null;
   return { model, flags };
 }
 
-// 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 deadline = Date.now() + timeoutMs;
-  const modelsUrl = `${endpointUrl}/models`;
-  let attempt = 0;
+function parseEnvFlag(envList) {
+  const obj = {};
+  for (const kv of (envList || [])) {
+    const idx = kv.indexOf('=');
+    if (idx > 0) obj[kv.slice(0, idx)] = kv.slice(idx + 1);
+  }
+  return obj;
+}
+
+// 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, healthPath = '/models') {
+  if (healthPath === '/models') {
+    if (elapsedSec < 45)  return 'Starting vLLM…';
+    if (elapsedSec < 150) return 'Downloading model…';
+    return 'Waiting for /v1/models…';
+  }
+  if (elapsedSec < 30)  return 'Starting container…';
+  if (elapsedSec < 120) return 'Container starting…';
+  return `Waiting for ${healthPath}…`;
+}
+
+function _detectHealthPath(image) {
+  if (!image) return null;
+  return image.toLowerCase().includes('comfyui') ? '/system_stats' : null;
+}
+
+/**
+ * Poll the model endpoint until /models returns 200, or timeout.
+ * Also checks deployment status on each iteration — fails fast if the dep is dead.
+ * Returns { ready: boolean, timedOut: boolean, depFailed: boolean, failReason?: string }
+ */
+async function waitForEndpoint(endpointUrl, deploymentId, config, timeoutMs = 5 * 60 * 1000, chalk, healthPath = '/models') {
+  const startMs  = Date.now();
+  const deadline = startMs + timeoutMs;
 
   while (Date.now() < deadline) {
-    attempt++;
+    // Check deployment status first — fail fast on OOM/crash before waiting more
+    try {
+      const dep = await callApi(`/deployments/${deploymentId}`, {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+        timeoutMs: 10_000,
+      });
+      if (['failed', 'terminated', 'error', 'stopped'].includes(dep.status)) {
+        process.stdout.write('\n');
+        return { ready: false, timedOut: false, depFailed: true, failReason: dep.error || dep.status };
+      }
+    } catch {
+      // status check failed — continue to endpoint check
+    }
+
     try {
-      const res = await fetch(modelsUrl, { signal: AbortSignal.timeout(8000) });
-      if (res.ok) return true;
+      const res = await fetch(`${endpointUrl}${healthPath}`, { signal: AbortSignal.timeout(8000) });
+      if (res.ok) { process.stdout.write('\n'); return { ready: true, timedOut: false, depFailed: false }; }
     } catch {
-      // network not up yet — keep polling
+      // still starting
     }
-    const elapsed = Math.round((Date.now() - (deadline - timeoutMs)) / 1000);
+
+    const elapsed = Math.round((Date.now() - startMs) / 1000);
     process.stdout.write(
-      `\r  ${chalk.dim(`Waiting for endpoint… ${elapsed}s (attempt ${attempt})`)}   `
+      `\r  ${chalk.dim(_serveStageLabel(elapsed, healthPath) + ` (${elapsed}s)`)}   `
     );
     await new Promise(r => setTimeout(r, 8000));
   }
+
   process.stdout.write('\n');
-  return false;
+  return { ready: false, timedOut: true, depFailed: false };
+}
+
+async function validateComfyNodes(baseUrl, nodeList, chalk) {
+  const nodes = nodeList.split(',').map(n => n.trim()).filter(Boolean);
+  if (!nodes.length) return;
+  const objectInfoUrl = baseUrl.replace(/\/v1\/?$/, '') + '/object_info';
+  console.log(chalk.dim(`\n  Checking custom nodes via ${objectInfoUrl}…`));
+  try {
+    const res = await fetch(objectInfoUrl, { signal: AbortSignal.timeout(15_000) });
+    if (!res.ok) {
+      console.log(chalk.yellow(`  ⚠ Could not verify nodes (HTTP ${res.status})`));
+      return;
+    }
+    const available = await res.json();
+    const found = nodes.filter(n => Object.prototype.hasOwnProperty.call(available, n));
+    const missing = nodes.filter(n => !Object.prototype.hasOwnProperty.call(available, n));
+    if (found.length) console.log(chalk.green(`  ✓ Nodes confirmed: ${found.join(', ')}`));
+    if (missing.length) {
+      console.log(chalk.yellow(`  ⚠ Nodes not found: ${missing.join(', ')}`));
+      console.log(chalk.dim('    These may not be installed in this image.'));
+    }
+  } catch (err) {
+    console.log(chalk.yellow(`  ⚠ Node check failed: ${err.message}`));
+  }
 }
 
+// Known badgr serve flags — used to detect broken shell line continuation.
+const _KNOWN_SERVE_FLAGS = new Set([
+  '--gpu', '--image', '--task', '--count', '--region', '--tier', '--max-price',
+  '--name', '--no-wait', '--max-cost', '--health-path', '--check-nodes',
+  '--no-fallback', '--strict-capacity', '--no-expanded-search', '--env',
+]);
+
 export async function serveCommand(config, args, chalk) {
   const { model, flags } = parseServeArgs(args);
+  const customImage = flags.image || null;
 
-  if (!model) {
-    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'));
+  // Detect flags that ended up as positional args due to broken shell line continuation
+  // (e.g. `\ ` with a trailing space instead of `\<newline>`).
+  // After parseServeArgs, only the model name should be in positional. Any extra token
+  // that matches a known badgr flag name was not parsed — likely a syntax mistake.
+  const servePositional = args.filter(a => !a.startsWith('-'));
+  const misplaced = servePositional.slice(1).filter(a => _KNOWN_SERVE_FLAGS.has(a));
+  if (misplaced.length > 0) {
+    console.error(chalk.red(`\n  ✗ These look like badgr flags but were treated as arguments:`));
+    console.error(chalk.red(`    ${misplaced.join(', ')}`));
+    console.error(chalk.dim(''));
+    console.error(chalk.dim('  This usually means a line continuation has a trailing space.'));
+    console.error(chalk.dim('  Use a single line, or end each continued line with \\ and no space after:'));
+    console.error(chalk.dim(''));
+    console.error(chalk.dim('    badgr serve meta-llama/Llama-3.1-8B-Instruct \\'));
+    console.error(chalk.dim('      --gpu L40S --max-cost 10'));
+    console.error(chalk.dim(''));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!model && !customImage) {
+    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('       badgr serve --image ghcr.io/my-org/api:latest --gpu L40S'));
     return;
   }
 
   requireApiKey(config);
 
-  const gpu = flags.gpu || 'L40S';
+  // ── Validate flags early ───────────────────────────────────────────────────
+  if (flags.count !== undefined && (!Number.isFinite(flags.count) || flags.count < 1)) {
+    console.error(chalk.red('  ✗ --count must be an integer greater than 0'));
+    process.exitCode = 1;
+    return;
+  }
+  if (flags.maxCost !== undefined && (!Number.isFinite(flags.maxCost) || flags.maxCost <= 0)) {
+    console.error(chalk.red('  ✗ --max-cost must be a number greater than 0'));
+    process.exitCode = 1;
+    return;
+  }
+  if (flags.region !== undefined && !['US', 'EU', 'AU'].includes(flags.region.toUpperCase())) {
+    console.error(chalk.red('  ✗ --region must be US, EU, or AU'));
+    process.exitCode = 1;
+    return;
+  }
 
-  console.log(chalk.bold('\n🚀 Serving model\n'));
-  console.log(`  ${chalk.bold('Model:')}  ${model}`);
-  console.log(`  ${chalk.bold('GPU:')}    ${gpu}`);
+  const envObj = parseEnvFlag(flags.env);
+
+  const gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : (customImage ? 'L40S' : 'AUTO');
+  const gpuLabel = gpu === 'AUTO' ? 'auto' : gpu;
+
+  const effectiveTier = normalizeTier(flags.tier);
+
+  if (customImage) {
+    console.log(chalk.bold('\n⚡ Serving custom container\n'));
+    console.log(`  ${chalk.bold('Image:')}  ${customImage}`);
+    console.log(`  ${chalk.bold('GPU:')}    ${gpuLabel}`);
+    if (flags.task) console.log(`  ${chalk.bold('Task:')}   ${flags.task}`);
+    if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}    ${flags.env.join(', ')}`);
+  } else {
+    console.log(chalk.bold('\n⚡ Serving model\n'));
+    console.log(`  ${chalk.bold('Model:')}  ${model}`);
+    console.log(`  ${chalk.bold('GPU:')}    ${gpuLabel}`);
+    if (flags.task) console.log(`  ${chalk.bold('Task:')}   ${flags.task}`);
+    if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}    ${flags.env.join(', ')}`);
+
+    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();
-  console.log(chalk.dim('  Finding best available GPU capacity...'));
+  process.stdout.write(chalk.dim('  Finding suitable capacity...\n'));
+
+  const effectiveRegion = flags.region ? flags.region.toUpperCase() : undefined;
+
+  function buildBody(gpuOverride, tierOverride) {
+    return {
+      ...(model ? { model } : {}),
+      ...(customImage ? { image: customImage } : {}),
+      ...(flags.task ? { task: flags.task } : {}),
+      gpu: gpuOverride || gpu,
+      gpu_count: flags.count || 1,
+      ...(effectiveRegion ? { region: effectiveRegion } : {}),
+      max_price_per_hour: flags.maxPrice,
+      name: flags.name,
+      tier: tierOverride || effectiveTier,
+      ...(Object.keys(envObj).length > 0 ? { env: envObj } : {}),
+    };
+  }
 
   let dep;
   try {
-    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,
-      },
-    });
+    dep = await callWithFallback(
+      '/serve',
+      { apiKey: config.apiKey, baseUrl: config.baseUrl },
+      (tierOverride) => buildBody(undefined, tierOverride),
+      effectiveTier,
+      chalk,
+      { thing: 'endpoint', cmd: 'badgr serve' },
+      { allowTier2Fallback: !flags.noMarketplaceFallback },
+    );
   } catch (err) {
-    console.error(chalk.red(`\n  ✗ Serve failed: ${err.message}\n`));
+    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`));
+      process.exitCode = 1;
+      return;
+    }
+    // CapacityError message is pre-formatted with chalk
+    console.error(err.message);
+    process.exitCode = 1;
     return;
   }
 
-  // Mirror to local store so badgr down/status/receipts work offline
   addDeployment({
     id:          dep.deployment_id,
     name:        dep.name,
@@ -98,12 +291,13 @@ 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();
@@ -111,49 +305,132 @@ 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;
+  // ── Fix 7: never fall back to config.baseUrl for endpoint health check ─────
+  const endpointUrl = dep.endpoint_url || dep.openai_base_url;
+  if (!endpointUrl) {
+    console.error(chalk.red(
+      `\n  ✗ Deployment ${dep.deployment_id} has no endpoint URL yet.\n` +
+      `  Run: badgr status ${dep.deployment_id}\n`
+    ));
+    updateReceipt(rcptId, { status: 'no_endpoint_url' });
+    process.exitCode = 1;
+    return;
+  }
 
-  // ── Health check before declaring "ready" ─────────────────────────────────
-  let endpointReady = false;
+  // ── Determine health check path ───────────────────────────────────────────
+  // Priority: explicit --health-path > auto-detect comfyui > /models for vLLM > null (skip)
+  let resolvedHealthPath;
+  if (flags.healthPath) {
+    resolvedHealthPath = flags.healthPath;
+  } else if (!customImage) {
+    resolvedHealthPath = '/models';
+  } else {
+    resolvedHealthPath = _detectHealthPath(customImage);  // '/system_stats' for comfyui, null otherwise
+  }
 
+  // ── Health check ──────────────────────────────────────────────────────────
+  let endpointReady = false;
   if (flags.noWait) {
-    console.log(chalk.yellow('\n⏳ Endpoint provisioning (skipped health check — use --no-wait)\n'));
+    console.log(chalk.yellow('\n  Skipped health check (--no-wait)\n'));
+  } else if (resolvedHealthPath === null) {
+    console.log(chalk.yellow(
+      '\n  Skipping health check (custom image — add --health-path /your-readiness-path to enable)\n'
+    ));
   } else {
-    console.log(chalk.dim('\n  Health-checking endpoint (up to 5 min)...'));
-    endpointReady = await waitForEndpoint(endpointUrl, 5 * 60 * 1000, chalk);
+    if (resolvedHealthPath !== '/models') {
+      process.stdout.write(chalk.dim(`  Checking ${resolvedHealthPath} for readiness…\n`));
+    }
+    // Check deployment status once before starting the 5-min wait
+    try {
+      const latest = await callApi(`/deployments/${dep.deployment_id}`, {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+        timeoutMs: 10_000,
+      });
+      if (['failed', 'terminated', 'error'].includes(latest.status)) {
+        console.error(formatCliError('HEALTH_CHECK_DEPLOY_FAILED', {
+          deploymentId: dep.deployment_id,
+          failReason:   latest.error || latest.status,
+        }, chalk));
+        updateReceipt(rcptId, { status: 'failed', failReason: latest.error || latest.status });
+        process.exitCode = 1;
+        return;
+      }
+    } catch {
+      // status check failed — proceed with endpoint poll anyway
+    }
+
+    const healthResult = await waitForEndpoint(endpointUrl, dep.deployment_id, config, 5 * 60 * 1000, chalk, resolvedHealthPath);
     process.stdout.write('\n');
+
+    if (healthResult.depFailed) {
+      console.error(formatCliError('HEALTH_CHECK_DEPLOY_FAILED', {
+        deploymentId: dep.deployment_id,
+        failReason:   healthResult.failReason,
+      }, chalk));
+      updateReceipt(rcptId, { status: 'failed', failReason: healthResult.failReason });
+      process.exitCode = 1;
+      return;
+    }
+
+    endpointReady = healthResult.ready;
+    if (!endpointReady) updateReceipt(rcptId, { status: 'health_check_timeout' });
+  }
+
+  // ── Custom-node validation (ComfyUI) ─────────────────────────────────────
+  if (flags.checkNodes && endpointReady) {
+    await validateComfyNodes(endpointUrl, flags.checkNodes, chalk);
   }
 
-  // ── Print result ──────────────────────────────────────────────────────────
+  // ── Update receipt with final state ───────────────────────────────────────
+  updateReceipt(rcptId, {
+    status:      endpointReady ? 'ready' : 'starting',
+    endpointUrl,
+    updatedAt:   new Date().toISOString(),
+  });
+
+  // ── Result ────────────────────────────────────────────────────────────────
   if (endpointReady) {
-    console.log(chalk.green('✓ Endpoint ready\n'));
+    console.log(chalk.green('\n  ✓ Endpoint ready\n'));
   } else {
-    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(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();
   }
 
-  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)}`);
+  const serveRate = dep.cost_per_hour || 0;
 
-  if (endpointReady) {
-    console.log(`\n  ${chalk.bold('Use with OpenAI SDK:')}`);
+  console.log(`  ${chalk.bold('Base URL:')}     ${chalk.cyan(endpointUrl)}`);
+  if (dep.model || model) console.log(`  ${chalk.bold('Model:')}        ${dep.model || model}`);
+  if (customImage)        console.log(`  ${chalk.bold('Image:')}        ${customImage}`);
+  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}`));
+
+  if (endpointReady && !customImage) {
+    const keySnip = config.apiKey?.slice(0, 4) || 'sk-...';
+    console.log(`  ${chalk.bold('Use with OpenAI SDK:')}`);
     console.log(chalk.dim(`    from openai import OpenAI`));
-    console.log(chalk.dim(`    client = OpenAI(api_key="${config.apiKey?.slice(0, 8) || 'sk-...'}...", base_url="${endpointUrl}")`));
+    console.log(chalk.dim(`    client = OpenAI(base_url="${endpointUrl}", api_key="${keySnip}...")`));
     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,24 +2,20 @@ 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(`  Could not reach API: ${err.message}. Showing local state.\n`));
+      console.log(chalk.yellow(`\n  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,
@@ -33,7 +29,6 @@ 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,
@@ -41,54 +36,46 @@ export async function statusCommand(config, args, chalk) {
     }));
   }
 
-  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'));
+  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'));
     return;
   }
 
-  const cols = { name: 16, type: 9, gpu: 11, status: 14, price: 9 };
+  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 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));
+    console.log(`  ${badge}  ${chalk.bold(id)}  ${type}  ${gpu}  ${rate}`);
 
-  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
-    );
-  });
+    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();
+  }
 
-  console.log();
+  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`);
+  }
 
-  // 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(chalk.bold('Stop billing:\n'));
+  for (const d of running) {
+    const id = d.deployment_id || d.name;
+    console.log(`  ${chalk.cyan(`badgr down ${id}`)}`);
   }
+  console.log();
 }