badgr-cli 1.0.42 → 1.0.44

package/src/commands/serve.js

@@ -1,9 +1,10 @@
 import { requireApiKey } from '../config.js';
 import { callApi, listDeployments } from '../api.js';
 import { addDeployment, addReceipt, updateReceipt, generateReceiptId } from '../store.js';
-import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
+import { normalizeTier, callWithFallback } from '../fallback.js';
 import { formatCliError } from '../errors.js';
-import { TEMPLATE_MAP, buildTemplateFlags, parseTemplateOverrides, BLESSED_VLLM_MODELS } from '../catalog.js';
+import { TEMPLATE_MAP, buildTemplateFlags, parseTemplateOverrides, BLESSED_VLLM_MODELS, isLikelyGatedModel } from '../catalog.js';
+import { stage as _stage, stageDone as _stageDone, writeBlock as _writeBlock, clearBlock as _clearBlock, renderLiveBlock as _renderLiveBlock } from '../progress.js';
 
 const LLAMA_CPP_IMAGE = 'michaelmanleyx/llama-cpp:server-cuda';
 
@@ -42,6 +43,7 @@ export function parseServeArgs(args) {
     if (args[i] === '--runtime')  { flags.runtime = args[++i]; i++; continue; }
     if (args[i] === '--hf-repo') { flags.hfRepo = args[++i]; i++; continue; }
     if (args[i] === '--hf-file') { flags.hfFile = args[++i]; i++; continue; }
+    if (args[i] === '--list-aliases') { flags.listAliases = true; i++; continue; }
     if (args[i] === '--env') {
       const kv = args[++i]; i++;
       if (!flags.env) flags.env = [];
@@ -63,18 +65,36 @@ function parseEnvFlag(envList) {
   return obj;
 }
 
+function envObjHasHfToken(envList) {
+  return (envList || []).some(kv => kv.startsWith('HF_TOKEN='));
+}
+
+// Extract a parameter-count-in-billions hint from a model/file name, e.g.
+// "Qwen2.5-0.5B-Instruct" → 0.5, "Llama-3.1-8B-Instruct" → 8, "Mixtral-8x7B" → 56.
+// Splits into delimiter-bounded segments first so a version number like "2.5"
+// in "Qwen2.5-0.5B" is never mistaken for the param count — only a segment that
+// IS entirely "<digits>b" or "<digits>x<digits>b" counts as a size hint.
+function _extractParamsB(name) {
+  const s = name.toLowerCase();
+  const segments = s.split(/[^a-z0-9.]+/).filter(Boolean);
+  for (const seg of segments) {
+    const moe = seg.match(/^(\d+)x(\d+)b$/);
+    if (moe) return parseInt(moe[1], 10) * parseInt(moe[2], 10);
+  }
+  for (const seg of segments) {
+    const m = seg.match(/^(\d+(?:\.\d+)?)b$/);
+    if (m) return parseFloat(m[1]);
+  }
+  return null;
+}
+
 // Mirror of backend workload_profile.py infer_profile_from_model — for pre-flight display.
+// Sizing is only asserted when a param-count hint is found in the name; unknown
+// sizing falls back to the 7B–8B/24GB+ default rather than guessing small or large.
 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;
-  }
+  const paramsB = _extractParamsB(modelName);
   if (paramsB === null) return { label: 'inference (7B–8B model)', vram: '24+ GB', gpus: ['RTX 4090', 'A6000', 'L40S'] };
+  if (paramsB <= 3)    return { label: 'inference (≤3B model)',    vram: '8+ GB',  gpus: ['RTX 3090', 'RTX 4090', 'L4'] };
   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'] };
@@ -83,35 +103,16 @@ function _inferServeProfile(modelName) {
 // Mirror of backend workload_profile.py infer_profile_from_gguf.
 // Accepts the --hf-file filename; looks for param-count hints like "35B" or "8x7B".
 function _inferGgufProfile(ggufPath) {
-  const s = ggufPath.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;
-  }
+  const paramsB = _extractParamsB(ggufPath);
   if (paramsB === null || paramsB <= 9) return { label: 'GGUF inference (≤9B, llama.cpp)',      vram: '8+ GB',  gpus: ['RTX 4090', 'RTX 3090', 'A6000'] };
   if (paramsB <= 35)                   return { label: 'GGUF inference (10B–35B, llama.cpp)',   vram: '24+ GB', gpus: ['RTX 4090', 'A6000', 'L40S'] };
   return                                      { label: 'GGUF inference (36B+, llama.cpp)',      vram: '48+ GB', gpus: ['A6000', 'L40S', '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 (healthPath === '/health') {
-    if (elapsedSec < 60)  return 'Starting server…';
-    if (elapsedSec < 180) return 'Downloading model…';
-    return 'Waiting for /health…';
-  }
-  if (elapsedSec < 30)  return 'Starting container…';
-  if (elapsedSec < 120) return 'Container starting…';
-  return `Waiting for ${healthPath}…`;
-}
+// If the readiness reason hasn't changed for this long, the status word
+// flips from "starting" to "stuck" so a silent stall never looks identical
+// to normal progress.
+const SERVE_STUCK_THRESHOLD_MS = 90_000;
 
 function _detectHealthPath(image) {
   if (!image) return null;
@@ -121,16 +122,26 @@ function _detectHealthPath(image) {
 }
 
 /**
- * Poll the model endpoint until /models returns 200, or timeout.
- * Also checks deployment status on each iteration — fails fast if the dep is dead.
+ * Wait for the deployment's app-level endpoint to become ready by polling Badgr's
+ * own deployment status (GET /deployments/{id}) — never the RunPod proxy/pod
+ * directly. The backend does the real health_path probing (see
+ * DeploymentService.check_endpoint_readiness); a pod reporting RUNNING only
+ * means infrastructure is up, not that the app inside is serving.
  * Returns { ready: boolean, timedOut: boolean, depFailed: boolean, failReason?: string }
  */
-async function waitForEndpoint(endpointUrl, deploymentId, config, timeoutMs = 5 * 60 * 1000, chalk, healthPath = '/models') {
+// vLLM cold start (model download + load) often exceeds 5 min on first boot.
+const VLLM_SERVE_WAIT_MS = 15 * 60 * 1000;
+
+async function waitForEndpoint(deploymentId, config, timeoutMs = VLLM_SERVE_WAIT_MS, chalk, healthPath = '/models', costCtx = {}) {
+  const { costPerHour = 0, maxCost = null, stageLine = '' } = costCtx;
   const startMs  = Date.now();
   const deadline = startMs + timeoutMs;
 
+  let lastReason     = null;
+  let reasonSinceMs  = startMs;
+  let blockLines     = 0;
+
   while (Date.now() < deadline) {
-    // Check deployment status first — fail fast on OOM/crash before waiting more
     try {
       const dep = await callApi(`/deployments/${deploymentId}`, {
         apiKey: config.apiKey,
@@ -138,28 +149,30 @@ async function waitForEndpoint(endpointUrl, deploymentId, config, timeoutMs = 5
         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 };
+        if (blockLines > 0) { _clearBlock(blockLines); blockLines = 0; }
+        return { ready: false, timedOut: false, depFailed: true, failReason: dep.fix_hint || dep.error || dep.status };
+      }
+      if (dep.endpoint_ready) {
+        if (blockLines > 0) { _clearBlock(blockLines); blockLines = 0; }
+        return { ready: true, timedOut: false, depFailed: false };
       }
-    } catch {
-      // status check failed — continue to endpoint check
-    }
 
-    try {
-      const res = await fetch(`${endpointUrl}${healthPath}`, { signal: AbortSignal.timeout(8000) });
-      if (res.ok) { process.stdout.write('\n'); return { ready: true, timedOut: false, depFailed: false }; }
+      const now     = Date.now();
+      const elapsed = Math.round((now - startMs) / 1000);
+      const reason  = dep.readiness_reason || 'starting';
+      if (reason !== lastReason) { lastReason = reason; reasonSinceMs = now; }
+      const statusWord = (now - reasonSinceMs) >= SERVE_STUCK_THRESHOLD_MS ? 'stuck' : 'still starting';
+      const spend   = costPerHour * (elapsed / 3600);
+
+      blockLines = _writeBlock(blockLines, _renderLiveBlock(chalk, {
+        stageLine, elapsedSec: elapsed, statusWord, spend, id: deploymentId,
+      }));
     } catch {
-      // still starting
+      // status check failed (transient network/API issue) — retry next tick
     }
-
-    const elapsed = Math.round((Date.now() - startMs) / 1000);
-    process.stdout.write(
-      `\r  ${chalk.dim(_serveStageLabel(elapsed, healthPath) + ` (${elapsed}s)`)}   `
-    );
     await new Promise(r => setTimeout(r, 8000));
   }
 
-  process.stdout.write('\n');
   return { ready: false, timedOut: true, depFailed: false };
 }
 
@@ -217,6 +230,18 @@ export async function serveCommand(config, args, chalk) {
     return serveCommand(config, expandedArgs, chalk);
   }
 
+  if (args.includes('--list-aliases')) {
+    console.log(chalk.bold('\nTested model routes:\n'));
+    for (const alias of Object.keys(BLESSED_VLLM_MODELS)) {
+      console.log(`  - ${chalk.cyan(alias)}`);
+    }
+    console.log();
+    console.log(chalk.dim('You can also try a Hugging Face model ID:'));
+    console.log(chalk.dim('  badgr serve Qwen/Qwen2.5-7B-Instruct --max-cost 10'));
+    console.log();
+    return;
+  }
+
   const { model, flags } = parseServeArgs(args);
   const customImage = flags.image || null;
   const isLlamaCpp = flags.runtime === 'llama.cpp';
@@ -304,50 +329,60 @@ export async function serveCommand(config, args, chalk) {
 
   const effectiveTier = normalizeTier(flags.tier);
 
+  // Header fields + trailing note (shown after Max cost) per serve mode.
+  // Built as [label, value] pairs so every mode renders through one aligned
+  // printer instead of four hand-spaced copies.
+  let title;
+  const headerLines = [];
+  let trailingNote = null;
+  let sizeProfile = null; // { label, vram } — only shown when GPU sizing was inferred, not chosen
+
   if (isLlamaCpp) {
-    console.log(chalk.bold('\n⚡ Serving HF GGUF (llama.cpp)\n'));
-    console.log(`  ${chalk.bold('HF Repo:')}  ${flags.hfRepo}`);
-    console.log(`  ${chalk.bold('HF File:')}  ${flags.hfFile}`);
-    console.log(`  ${chalk.bold('Runtime:')}  llama.cpp`);
-    console.log(`  ${chalk.bold('GPU:')}      ${gpuLabel}`);
-    if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}      ${flags.env.join(', ')}`);
-    if (gpu === 'AUTO') {
-      const prof = _inferGgufProfile(flags.hfFile);
-      console.log();
-      console.log(`  ${chalk.bold('Estimated workload:')}      ${prof.label}`);
-      console.log(`  ${chalk.bold('Estimated minimum VRAM:')}  ${prof.vram}`);
-    }
+    title = flags.hfRepo;
+    headerLines.push(['Route', 'best-effort Hugging Face model']);
+    headerLines.push(['Mode', 'OpenAI-compatible endpoint (llama.cpp)']);
+    headerLines.push(['File', flags.hfFile]);
+    trailingNote = 'Badgr will try a compatible route.';
+    if (gpu === 'AUTO') sizeProfile = _inferGgufProfile(flags.hfFile);
   } else 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(', ')}`);
+    title = 'custom container';
+    headerLines.push(['Mode', 'custom server']);
+    trailingNote = 'Badgr manages runtime, logs, caps, teardown, and receipts.\n  Your container owns the app behavior.';
+  } else if (vllmAlias) {
+    title = model;
+    headerLines.push(['Route', 'tested']);
+    headerLines.push(['Mode', 'OpenAI-compatible endpoint']);
   } else {
-    console.log(chalk.bold('\n⚡ Serving model\n'));
-    if (vllmAlias) {
-      console.log(`  ${chalk.bold('Alias:')}  ${model}  ${chalk.dim(`→ ${effectiveModel}`)}`);
-    } else {
-      console.log(`  ${chalk.bold('Model:')}  ${effectiveModel}`);
-    }
-    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(effectiveModel);
-      console.log();
-      console.log(`  ${chalk.bold('Estimated workload:')}      ${prof.label}`);
-      console.log(`  ${chalk.bold('Estimated minimum VRAM:')}  ${prof.vram}`);
-    }
+    title = effectiveModel;
+    headerLines.push(['Route', 'best-effort Hugging Face model']);
+    headerLines.push(['Mode', 'OpenAI-compatible endpoint']);
+    trailingNote = 'Badgr will try a compatible route.';
+    if (gpu === 'AUTO') sizeProfile = _inferServeProfile(effectiveModel);
   }
-  if (flags.maxCost) {
-    console.log(`  ${chalk.bold('Max cost:')}    $${flags.maxCost.toFixed(2)} (auto-stop)`);
-  } else {
-    console.log(chalk.yellow(`  ⚠  Persistent — billing until: badgr down <id>  or  badgr down --all`));
+  if (flags.gpu) headerLines.push(['GPU', gpuLabel]);
+  if (flags.task) headerLines.push(['Task', flags.task]);
+  if (flags.env?.length) headerLines.push(['Env', flags.env.join(', ')]);
+
+  console.log(chalk.bold(`\n⚡ Serving ${title}\n`));
+  const labelWidth = Math.max(...headerLines.map(([label]) => label.length)) + 1;
+  for (const [label, value] of headerLines) {
+    console.log(`  ${chalk.bold(`${label}:`.padEnd(labelWidth + 1))}${value}`);
+  }
+  if (sizeProfile) {
+    console.log();
+    console.log(`  ${chalk.bold('Estimated workload:')}      ${sizeProfile.label}`);
+    console.log(`  ${chalk.bold('Estimated minimum VRAM:')}  ${sizeProfile.vram}`);
+  }
+  console.log(`  ${chalk.bold('Max cost:')}    ${flags.maxCost ? `$${flags.maxCost.toFixed(2)}` : chalk.dim('none')}`);
+  console.log(`  ${chalk.bold('Auto-stop:')}   ${flags.maxCost ? 'enabled' : chalk.yellow('disabled — stop manually with badgr down')}`);
+  if (trailingNote) {
+    console.log();
+    console.log(chalk.dim(`  ${trailingNote}`));
   }
   console.log();
-  process.stdout.write(chalk.dim('  Finding suitable capacity...\n'));
+
+  const STAGE_TOTAL = 5;
+  let stageN = 1;
 
   // ── Duplicate check ────────────────────────────────────────────────────────
   if (config.apiKey) {
@@ -402,6 +437,7 @@ export async function serveCommand(config, args, chalk) {
       tier: tierOverride || effectiveTier,
       ...(Object.keys(effectiveEnv).length > 0 ? { env: effectiveEnv } : {}),
       ...(flags.maxCost ? { max_cost_usd: flags.maxCost } : {}),
+      ...(flags.healthPath ? { health_path: flags.healthPath } : {}),
     };
   }
 
@@ -458,6 +494,11 @@ export async function serveCommand(config, args, chalk) {
     createdAt:    new Date().toISOString(),
   });
 
+  console.log(chalk.dim(_stageDone(stageN, STAGE_TOTAL, 'Finding a working route...')));
+  stageN++;
+  console.log(chalk.dim(_stageDone(stageN, STAGE_TOTAL, 'Starting runtime...')));
+  stageN++;
+
   // ── Fix 7: never fall back to config.baseUrl for endpoint health check ─────
   const endpointUrl = dep.endpoint_url || dep.openai_base_url;
   if (!endpointUrl) {
@@ -488,18 +529,47 @@ export async function serveCommand(config, args, chalk) {
     resolvedHealthPath = _detectHealthPath(customImage);  // '/system_stats' for comfyui, null otherwise
   }
 
+  // Gated-model guidance is only shown when it's actually needed — on failure —
+  // not up front, so common launches stay short and uncluttered.
+  const gatedModelId = isLlamaCpp ? flags.hfRepo : effectiveModel;
+  const gatedHintNeeded = isLikelyGatedModel(gatedModelId) && !envObjHasHfToken(flags.env);
+
+  // Shared reporting for "deployment failed to start" — hit from both the
+  // pre-poll status check and the waitForEndpoint poll loop below.
+  function reportDeployFailure(failReason) {
+    console.error(formatCliError('HEALTH_CHECK_DEPLOY_FAILED', {
+      deploymentId: dep.deployment_id,
+      failReason,
+    }, chalk));
+    if (gatedHintNeeded) {
+      const rerun = args.join(' ');
+      const retryCmd = rerun.includes('HF_TOKEN=') ? rerun : `${rerun} --env HF_TOKEN=$HF_TOKEN`;
+      console.error();
+      console.error(chalk.yellow('  This model may require Hugging Face access.'));
+      console.error(chalk.dim('  Retry:'));
+      console.error(chalk.dim(`    badgr serve ${retryCmd}`));
+    }
+    updateReceipt(rcptId, { status: 'failed', failReason });
+    process.exitCode = 1;
+  }
+
   // ── Health check ──────────────────────────────────────────────────────────
+  const loadingStageN = stageN;      // "Loading model..."
+  const healthStageN  = stageN + 1;  // "Checking endpoint health..."
+  const readyStageN   = stageN + 2;  // "Ready"
+
   let endpointReady = false;
   if (flags.noWait) {
-    console.log(chalk.yellow('\n  Skipped health check (--no-wait)\n'));
+    console.log(chalk.dim(_stage(loadingStageN, STAGE_TOTAL, 'Loading model...')) + chalk.yellow('  (skipped — --no-wait)'));
+    console.log(chalk.dim(_stage(healthStageN, STAGE_TOTAL, 'Checking endpoint health...')) + chalk.yellow('  (skipped — --no-wait)'));
+    console.log(chalk.yellow(_stage(readyStageN, STAGE_TOTAL, 'Not confirmed ready — check badgr logs') + `\n`));
   } else if (resolvedHealthPath === null) {
+    console.log(chalk.dim(_stage(loadingStageN, STAGE_TOTAL, 'Loading model...')));
     console.log(chalk.yellow(
-      '\n  Skipping health check (custom image — add --health-path /your-readiness-path to enable)\n'
+      _stage(healthStageN, STAGE_TOTAL, 'Checking endpoint health...') +
+      '  (skipped — custom image; add --health-path /your-readiness-path to enable)\n'
     ));
   } else {
-    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}`, {
@@ -508,33 +578,31 @@ export async function serveCommand(config, args, chalk) {
         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;
+        reportDeployFailure(latest.error || latest.status);
         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');
+    const loadingStageLine = _stage(loadingStageN, STAGE_TOTAL, 'Loading model...');
+    const healthResult = await waitForEndpoint(
+      dep.deployment_id, config, VLLM_SERVE_WAIT_MS, chalk, resolvedHealthPath,
+      { costPerHour: dep.cost_per_hour || 0, maxCost: flags.maxCost || null, stageLine: loadingStageLine },
+    );
 
     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;
+      reportDeployFailure(healthResult.failReason);
       return;
     }
 
     endpointReady = healthResult.ready;
-    if (!endpointReady) updateReceipt(rcptId, { status: 'health_check_timeout' });
+    if (endpointReady) {
+      console.log(chalk.dim(_stage(healthStageN, STAGE_TOTAL, 'Checking endpoint health...')));
+      console.log(chalk.green(_stage(readyStageN, STAGE_TOTAL, 'Ready')));
+    } else {
+      updateReceipt(rcptId, { status: 'health_check_timeout' });
+    }
   }
 
   // ── Custom-node validation (ComfyUI) ─────────────────────────────────────
@@ -559,8 +627,6 @@ export async function serveCommand(config, args, chalk) {
     console.log();
   }
 
-  const serveRate = dep.cost_per_hour || 0;
-
   console.log(`  ${chalk.bold('Base URL:')}     ${chalk.cyan(endpointUrl)}`);
   if (isLlamaCpp) {
     console.log(`  ${chalk.bold('HF Repo:')}      ${flags.hfRepo}`);
@@ -568,23 +634,20 @@ export async function serveCommand(config, args, chalk) {
   }
   else if (dep.model || effectiveModel) console.log(`  ${chalk.bold('Model:')}        ${dep.model || effectiveModel}`);
   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('Logs:')}         badgr logs ${dep.deployment_id}`);
   console.log(`  ${chalk.bold('Stop billing:')} ${chalk.cyan(`badgr down ${dep.deployment_id}`)}`);
+  console.log(`  ${chalk.bold('Receipt:')}      badgr receipts ${rcptId}`);
   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-...';
     const sdkModel = isLlamaCpp ? 'default' : (dep.model || effectiveModel);
+    console.log(`  ${chalk.bold('Test with curl:')}`);
+    console.log(chalk.dim(`    curl ${endpointUrl}/chat/completions \\`));
+    console.log(chalk.dim(`      -H "Authorization: Bearer ${keySnip}..." -H "Content-Type: application/json" \\`));
+    console.log(chalk.dim(`      -d '{"model":"${sdkModel}","messages":[{"role":"user","content":"Hello"}]}'`));
     console.log(`  ${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}...")`));

package/src/commands/train.js

@@ -21,6 +21,17 @@ const TRAINING_IMAGES = {
   generic: 'nvidia/cuda:12.1.0-cudnn8-devel-ubuntu22.04',
 };
 
+// Container command per framework — must match what's actually installed in
+// TRAINING_IMAGES[framework]. A framework with no entry here has no known
+// working command and is blocked in trainCommand() rather than guessed at,
+// since a wrong guess still provisions (and bills) the GPU before failing.
+const TRAINING_COMMANDS = {
+  axolotl: 'echo "$TRAIN_CONFIG_B64" | base64 -d > /tmp/config.yaml && axolotl train /tmp/config.yaml',
+  // huggingface/trl-source ships the `trl` CLI (trl sft|dpo|kto --config <yaml>).
+  // We default to `sft` — the common case for a plain base_model+dataset config.
+  trl:     'echo "$TRAIN_CONFIG_B64" | base64 -d > /tmp/config.yaml && trl sft --config /tmp/config.yaml',
+};
+
 // Preferred GPUs for training: VRAM-heavy workloads.
 const TRAINING_GPUS = ['A100', 'H100', 'L40S', 'A6000'];
 
@@ -104,11 +115,18 @@ export function parseTrainLoraArgs(args) {
     if (a === '--max-runtime')  { flags.maxRuntime = parseFloat(args[++i]); i++; continue; }
     if (a === '--tier')         { flags.tier = args[++i]; i++; continue; }
     if (a === '--gpu-type')     { flags.gpuType = args[++i]; i++; continue; }
+    if (a === '--dry-run')      { flags.dryRun = true; i++; continue; }
     i++;
   }
   return flags;
 }
 
+// Mirror of backend LORA_PRESETS (jobs_routes.py) — display only, server is authoritative.
+export const LORA_PRESET_INFO = {
+  small:  { gpu_type: 'RTX_4090', rank: 16, epochs: 3, description: 'Fast, low-cost — good default for most datasets' },
+  medium: { gpu_type: 'A100',     rank: 32, epochs: 5, description: 'Larger rank/more epochs — bigger datasets or higher quality' },
+};
+
 export async function trainLoraCommand(config, args, chalk) {
   const { callApi } = await import('../api.js');
   const { addReceipt, generateReceiptId } = await import('../store.js');
@@ -124,12 +142,31 @@ export async function trainLoraCommand(config, args, chalk) {
     return;
   }
 
-  if (!flags.maxCost) {
+  if (!flags.maxCost && !flags.dryRun) {
     console.error(chalk.red('\n  ✗ --max-cost is required to cap GPU spend.\n'));
     process.exitCode = 1;
     return;
   }
 
+  if (flags.dryRun) {
+    const preset = flags.preset || 'small';
+    const presetInfo = LORA_PRESET_INFO[preset];
+    console.log(chalk.bold('\n⚡ Dry run — no GPU will be provisioned\n'));
+    console.log(`  ${chalk.bold('Base model:')}   ${flags.baseModel}`);
+    console.log(`  ${chalk.bold('Dataset:')}      ${flags.fileId || flags.dataset || chalk.dim('(none given)')}`);
+    console.log(`  ${chalk.bold('Preset:')}       ${preset}${presetInfo ? '' : chalk.yellow(' (unknown — server will reject this)')}`);
+    if (presetInfo) {
+      console.log(`  ${chalk.bold('GPU:')}          ${flags.gpuType || presetInfo.gpu_type}`);
+      console.log(`  ${chalk.bold('LoRA rank:')}    ${presetInfo.rank}`);
+      console.log(`  ${chalk.bold('Epochs:')}       ${presetInfo.epochs}`);
+      console.log(`  ${chalk.dim(presetInfo.description)}`);
+    }
+    if (flags.maxCost)    console.log(`  ${chalk.bold('Max cost:')}     $${flags.maxCost}`);
+    console.log(`  ${chalk.bold('Max runtime:')}  ${flags.maxRuntime ?? 240}min`);
+    console.log(chalk.dim('\n  Remove --dry-run to submit (local file datasets are uploaded first).\n'));
+    return;
+  }
+
   requireApiKey(config);
 
   // Build dataset input field
@@ -147,11 +184,23 @@ export async function trainLoraCommand(config, args, chalk) {
       return;
     }
     console.log(chalk.dim(`\n  Uploading dataset ${flags.dataset}…`));
-    const FormData = (await import('formdata-node')).FormData;
-    const { fileFromPath } = await import('formdata-node/file-from-path');
+    const { readFileSync: readDs } = await import('fs');
+    const fileData = readDs(flags.dataset);
     const form = new FormData();
-    form.set('file', await fileFromPath(flags.dataset));
-    const uploadResp = await callApi(config, 'POST', '/v1/uploads', null, form);
+    form.append('file', new Blob([fileData]), flags.dataset.split('/').pop() || 'dataset.jsonl');
+    const baseUrl = config.baseUrl.replace(/\/v1\/?$/, '');
+    const uploadRes = await fetch(`${baseUrl}/v1/uploads`, {
+      method: 'POST',
+      body: form,
+      headers: { Authorization: `Bearer ${config.apiKey}` },
+    });
+    if (!uploadRes.ok) {
+      const text = await uploadRes.text().catch(() => '');
+      console.error(chalk.red(`\n  ✗ Dataset upload failed: ${uploadRes.status}${text ? ` — ${text}` : ''}\n`));
+      process.exitCode = 1;
+      return;
+    }
+    const uploadResp = await uploadRes.json();
     input.dataset_file_id = uploadResp.upload_id;
     console.log(chalk.dim(`  Uploaded: ${uploadResp.upload_id}`));
   }
@@ -169,10 +218,15 @@ export async function trainLoraCommand(config, args, chalk) {
 
   let job;
   try {
-    job = await callApi(config, 'POST', '/v1/jobs', {
-      type: 'train.lora',
-      input,
-      policy: { max_cost: flags.maxCost, max_runtime_minutes: maxRuntime, tier: flags.tier },
+    job = await callApi('/jobs', {
+      method: 'POST',
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+      body: {
+        type: 'train.lora',
+        input,
+        policy: { max_cost: flags.maxCost, max_runtime_minutes: maxRuntime, tier: flags.tier },
+      },
     });
   } catch (err) {
     console.error(chalk.red(`\n  ✗ Failed to submit job: ${err.message}\n`));
@@ -191,7 +245,12 @@ export async function trainLoraCommand(config, args, chalk) {
   while (Date.now() - startMs < maxMs) {
     await new Promise(r => setTimeout(r, 15_000));
     let detail;
-    try { detail = await callApi(config, 'GET', `/v1/jobs/${job.job_id}`); } catch { continue; }
+    try {
+      detail = await callApi(`/jobs/${job.job_id}`, {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+      });
+    } catch { continue; }
     process.stdout.write(`\r  Status: ${detail.status}  elapsed: ${Math.floor((Date.now() - startMs) / 1000)}s  `);
     if (detail.status === 'completed') {
       const out = detail.output || {};
@@ -287,12 +346,27 @@ export async function trainCommand(config, args, chalk) {
   console.log(`  ${chalk.bold('Max runtime:')} ${runtimeLabel}`);
   if (maxCost) console.log(`  ${chalk.bold('Max cost:')}    $${maxCost.toFixed(2)}`);
   console.log();
+
+  // Block before provisioning: TRAINING_IMAGES[framework] and the container
+  // command must be a matched pair, or the job burns GPU time and then fails
+  // (e.g. an axolotl `train` binary that doesn't exist in the unsloth image).
+  const trainCmd = TRAINING_COMMANDS[framework];
+  if (!trainCmd) {
+    console.error(chalk.red(`  ✗ No runnable command for framework '${framework}' — refusing to provision a GPU that will fail.\n`));
+    console.error(chalk.dim(`    '${image}' does not have a known working entrypoint for this config yet.`));
+    console.error(chalk.dim(`    Options:`));
+    console.error(chalk.dim(`      --framework axolotl   force Axolotl (it has native Unsloth-optimization support via config keys)`));
+    console.error(chalk.dim(`      badgr train lora ...  use the productized LoRA path instead\n`));
+    process.exitCode = 1;
+    return;
+  }
+
   process.stdout.write(chalk.dim('  Finding suitable capacity...\n'));
 
   function buildBody(tierOverride) {
     return {
       image,
-      command: ['sh', '-c', 'echo "$TRAIN_CONFIG_B64" | base64 -d > /tmp/config.yaml && axolotl train /tmp/config.yaml'],
+      command: ['sh', '-c', trainCmd],
       gpu,
       gpu_count:          1,
       ...(flags.region ? { region: flags.region.toUpperCase() } : {}),