badgr-cli 1.1.0 → 1.1.2

package/src/commands/comfyui.js

@@ -7,12 +7,14 @@
  */
 import { readFileSync, existsSync } from 'fs';
 import { ensureBadgrReady } from '../onboarding.js';
+import { requireApiKey } from '../config.js';
 import { callApi, listDeployments } from '../api.js';
 import { addDeployment, addReceipt, updateReceipt, generateReceiptId } from '../store.js';
 import { normalizeTier, callWithFallback } from '../fallback.js';
 import { formatCliError } from '../errors.js';
 import { BLESSED_COMFY_WORKFLOWS } from '../catalog.js';
-import { pollJobUntilTerminal, renderJobClosingBlock, stage as _stage, stageDone as _stageDone, writeBlock as _writeBlock, clearBlock as _clearBlock, renderLiveBlock as _renderLiveBlock, printFailureClass as _printFailureClass } from '../progress.js';
+import { parseEnvFlag } from '../envFlag.js';
+import { pollJobUntilTerminal, renderJobClosingBlock, stage as _stage, stageDone as _stageDone, writeBlock as _writeBlock, clearBlock as _clearBlock, renderLiveBlock as _renderLiveBlock, printFailureClass as _printFailureClass, printCapacityPreview, formatTierLabel } from '../progress.js';
 
 const COMFYUI_IMAGE   = process.env.COMFYUI_IMAGE || 'yanwk/comfyui-boot:cu126-megapak';
 const HEALTH_PATH     = '/system_stats';
@@ -35,6 +37,7 @@ export function parseComfyuiArgs(args) {
     if (a === '--check-nodes') { flags.checkNodes = args[++i]; i++; continue; }
     if (a === '--persistent')  { flags.persistent = true; i++; continue; }
     if (a === '--yes' || a === '-y') { flags.yes = true; i++; continue; }
+    if (a === '--dry-run')     { flags.dryRun = true; i++; continue; }
     if (a === '--env') {
       const kv = args[++i]; i++;
       if (!flags.env) flags.env = [];
@@ -46,15 +49,6 @@ export function parseComfyuiArgs(args) {
   return { workflow: positional[0] || null, flags };
 }
 
-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;
-}
-
 // Live block while ComfyUI comes up — same generic "Checking health" stage
 // line and status block as every other launch path (see serve.js's
 // waitForEndpoint), so ComfyUI doesn't read as a different UX than vLLM.
@@ -179,16 +173,20 @@ export async function comfyBatchCommand(config, args, chalk) {
 
   if (flags.dryRun) {
     const workflowSpec = BLESSED_COMFY_WORKFLOWS[flags.workflow];
+    const resolvedGpu = flags.gpuType || workflowSpec?.gpu_type;
     console.log(chalk.bold('\n⚡ Dry run — no GPU will be provisioned\n'));
     console.log(`  ${chalk.bold('Workflow:')}     ${flags.workflow}${workflowSpec ? '' : chalk.yellow(' (unknown — server will reject this)')}`);
     if (workflowSpec) {
-      console.log(`  ${chalk.bold('GPU:')}          ${flags.gpuType || workflowSpec.gpu_type}`);
+      console.log(`  ${chalk.bold('GPU:')}          ${resolvedGpu}`);
       console.log(`  ${chalk.dim(workflowSpec.description)}`);
     }
     console.log(`  ${chalk.bold('Prompts:')}      ${prompts.length}${prompts.length > 20 ? chalk.yellow(' (exceeds the 20-prompt limit — server will reject this)') : ''}`);
+    console.log(`  ${chalk.bold('Tier:')}         ${formatTierLabel(normalizeTier(flags.tier))}`);
     if (flags.maxCost)    console.log(`  ${chalk.bold('Max cost:')}     $${flags.maxCost}`);
     console.log(`  ${chalk.bold('Max runtime:')}  ${flags.maxRuntime ?? 60}min`);
-    console.log(chalk.dim('\n  Remove --dry-run to submit.\n'));
+    console.log();
+    if (resolvedGpu) await printCapacityPreview(chalk, config, { gpu: resolvedGpu });
+    console.log(chalk.dim('  Remove --dry-run to submit.\n'));
     return;
   }
 
@@ -282,9 +280,15 @@ export async function comfyuiCommand(config, args, chalk) {
     return;
   }
 
-  config = await ensureBadgrReady(config, chalk);
+  // A dry run previews the plan only and never provisions or spends anything,
+  // so it doesn't need the interactive browser login — just a stored key.
+  if (flags.dryRun) {
+    requireApiKey(config);
+  } else {
+    config = await ensureBadgrReady(config, chalk);
+  }
 
-  if (!flags.maxCost && !flags.persistent) {
+  if (!flags.maxCost && !flags.persistent && !flags.dryRun) {
     console.error(chalk.red('\n  ✗ ComfyUI endpoints bill continuously. Specify a spending limit:\n'));
     console.error(chalk.dim('    --max-cost 5           auto-stop when $5 is reached'));
     console.error(chalk.dim('    --persistent           run until you stop it manually\n'));
@@ -328,17 +332,29 @@ export async function comfyuiCommand(config, args, chalk) {
   const STAGE_TOTAL = 4;
   let stageN = 1;
 
-  console.log(chalk.bold('\n⚡ Running ComfyUI\n'));
+  console.log(chalk.bold(flags.dryRun
+    ? '\n⚡ Dry run — no GPU will be provisioned — ComfyUI\n'
+    : '\n⚡ Running ComfyUI\n'));
   console.log(`  ${chalk.bold('Workflow:')} ${workflow} (${nodeCount} nodes)`);
   console.log(`  ${chalk.bold('Image:')}    ${COMFYUI_IMAGE}`);
   console.log(`  ${chalk.bold('GPU:')}      ${gpu === 'AUTO' ? chalk.dim('auto (16+ GB VRAM)') : gpu}`);
+  if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}      ${flags.env.join(', ')}`);
+  if (flags.dryRun) console.log(`  ${chalk.bold('Tier:')}     ${formatTierLabel(effectiveTier)}`);
   if (flags.maxCost) {
     console.log(`  ${chalk.bold('Max cost:')} $${flags.maxCost.toFixed(2)} (auto-stop)`);
+  } else if (flags.dryRun) {
+    console.log(`  ${chalk.bold('Max cost:')} ${chalk.dim('none')}`);
   } else {
     console.log(chalk.yellow('  ⚠  Persistent — billing until: badgr down <id>'));
   }
   console.log();
 
+  if (flags.dryRun) {
+    await printCapacityPreview(chalk, config, { gpu, region: flags.region?.toUpperCase(), maxPrice: flags.maxPrice });
+    console.log(chalk.dim('  Remove --dry-run to provision.\n'));
+    return;
+  }
+
   // Duplicate check
   if (config.apiKey) {
     try {

package/src/commands/embed.js

@@ -14,6 +14,8 @@ import { requireApiKey } from '../config.js';
 import { addReceipt, generateReceiptId } from '../store.js';
 import { normalizeTier, callWithFallback } from '../fallback.js';
 import { monitorBatchJob, fmtRuntime } from '../batch.js';
+import { parseEnvFlag } from '../envFlag.js';
+import { printCapacityPreview, formatTierLabel } from '../progress.js';
 
 const EMBED_IMAGE          = 'vllm/vllm-openai:latest';
 const DEFAULT_EMBED_MODEL  = 'BAAI/bge-large-en-v1.5';
@@ -35,6 +37,7 @@ export function parseEmbedArgs(args) {
     if (a === '--region')      { flags.region = args[++i]; i++; continue; }
     if (a === '--batch-size')  { flags.batchSize = parseInt(args[++i], 10); i++; continue; }
     if (a === '--detach')      { flags.detach = true; i++; continue; }
+    if (a === '--dry-run')     { flags.dryRun = true; i++; continue; }
     if (a === '--env') {
       const kv = args[++i]; i++;
       if (!flags.env) flags.env = [];
@@ -49,15 +52,6 @@ export function parseEmbedArgs(args) {
   return { model, input, flags };
 }
 
-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;
-}
-
 function isUrl(s) {
   return /^(https?|s3|gs|hf):\/\//i.test(s);
 }
@@ -120,14 +114,23 @@ export async function embedCommand(config, args, chalk) {
     ...(flags.batchSize    ? { EMBED_BATCH_SIZE: String(flags.batchSize) } : {}),
   };
 
-  console.log(chalk.bold('\n📐 Embeddings\n'));
+  console.log(chalk.bold(flags.dryRun ? '\n📐 Dry run — no GPU will be provisioned — Embeddings\n' : '\n📐 Embeddings\n'));
   console.log(`  ${chalk.bold('Input:')}       ${resolved.inputLabel}`);
   console.log(`  ${chalk.bold('Model:')}       ${model}`);
   console.log(`  ${chalk.bold('Image:')}       ${EMBED_IMAGE}`);
   console.log(`  ${chalk.bold('GPU:')}         ${gpu === 'AUTO' ? chalk.dim('auto (8+ GB VRAM)') : gpu}`);
+  if (flags.dryRun) console.log(`  ${chalk.bold('Tier:')}        ${formatTierLabel(effectiveTier)}`);
   console.log(`  ${chalk.bold('Max runtime:')} ${maxRuntimeMin}min`);
   if (maxCost) console.log(`  ${chalk.bold('Max cost:')}    $${maxCost.toFixed(2)}`);
+  if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}         ${flags.env.join(', ')}`);
   console.log();
+
+  if (flags.dryRun) {
+    await printCapacityPreview(chalk, config, { gpu, region: flags.region?.toUpperCase(), maxPrice: flags.maxPrice });
+    console.log(chalk.dim('  Remove --dry-run to submit.\n'));
+    return;
+  }
+
   process.stdout.write(chalk.dim('  Finding suitable capacity...\n'));
 
   function buildBody(tierOverride) {

package/src/commands/launch.js

@@ -286,15 +286,20 @@ async function launchAgentWorkload(config, agentName, rawArgs, chalk) {
     const envKey = PROVIDER_ENV_KEYS[spec.provider];
     const userSuppliedKey = flags.env?.some(kv => kv.startsWith(`${envKey}=`));
     let credential = userSuppliedKey ? null : getCredential(spec.provider);
+    flags.authRequired = { provider: spec.provider, status: credential || userSuppliedKey ? 'connected' : 'missing' };
     if (!credential && !userSuppliedKey) {
       // Missing credential no longer forces a separate `badgr connect` +
       // rerun in an interactive terminal — prompt inline and continue the
-      // same launch. Non-interactive contexts still hard-fail as before.
+      // same launch (including under --dry-run, so the dry-run preview
+      // reflects the connected state the real launch will actually use, and
+      // a follow-up real launch never needs a second prompt). Non-interactive
+      // contexts still hard-fail as before.
       credential = await resolveMissingCredential(spec.provider, chalk);
       if (!credential) {
         process.exitCode = 1;
         return;
       }
+      flags.authRequired.status = 'connected';
     }
     // An explicit --env always wins over the stored credential — never
     // append the injected default alongside a user-supplied value for the
@@ -304,6 +309,8 @@ async function launchAgentWorkload(config, agentName, rawArgs, chalk) {
       if (!flags.env) flags.env = [];
       flags.env.push(`${envKey}=${credential}`);
     }
+  } else {
+    flags.authRequired = { provider: null, status: 'none' };
   }
   // cline has no `provider` — Badgr mints and injects its own short-lived
   // job-scoped model token server-side (see backend jobs_routes.py); the

package/src/commands/login.js

@@ -1,36 +1,91 @@
-import { input } from '@inquirer/prompts';
-import { DEFAULTS } from '../config.js';
+import { DEFAULTS, loadConfig } from '../config.js';
 import { callApi } from '../api.js';
+import { ensureLoggedIn } from '../onboarding.js';
 
-export async function loginCommand(chalk, saveConfigFn) {
+const API_KEYS_URL = 'https://aibadgr.com/dashboard/api-keys';
+
+function parseArgs(args) {
+  const flags = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--key') flags.key = args[++i];
+  }
+  return flags;
+}
+
+/**
+ * badgr login             — interactive TTY: if a saved key is already
+ *                            valid, reports that and stops (no browser
+ *                            round-trip). Otherwise opens a browser login
+ *                            link and polls until it completes (same flow
+ *                            `badgr run`/`launch`/`serve`/`comfyui` trigger
+ *                            just-in-time — see onboarding.js's
+ *                            ensureLoggedIn).
+ * badgr login --key <key> — non-interactive: paste an existing key directly
+ *                            (CI, scripts, or anyone who already has one).
+ *
+ * The pasted-key path validates against a live API call before saving —
+ * a confirmed-invalid key (401/403) is never written to
+ * ~/.badgr/config.json. A network failure during validation still saves
+ * the key (with a warning), since that failure says nothing about whether
+ * the key itself is valid.
+ */
+export async function loginCommand(chalk, saveConfigFn, args = []) {
   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 flags = parseArgs(args);
 
-  const config = saveConfigFn({
-    apiKey: apiKey.trim(),
-    baseUrl: DEFAULTS.baseUrl,
-  });
+  if (!flags.key) {
+    if (process.stdin.isTTY && process.stdout.isTTY) {
+      const existing = loadConfig();
+      if (existing.apiKey) {
+        try {
+          await callApi('/models', { apiKey: existing.apiKey, baseUrl: existing.baseUrl });
+          console.log(chalk.green('✓ Already logged in'));
+          console.log(chalk.dim(`  Run ${chalk.cyan('badgr login --key <value>')} to switch accounts.\n`));
+          return existing;
+        } catch (err) {
+          if (err.httpStatus !== 401 && err.httpStatus !== 403) {
+            console.log(chalk.yellow('  ⚠ Could not reach the API to confirm the saved key — logging in again.'));
+          }
+          // Confirmed-invalid or unverifiable — fall through to re-auth below.
+        }
+      }
 
-  console.log(chalk.green('\n✓ Logged in'));
-  console.log(chalk.dim(`  Config saved to ~/.badgr/config.json`));
+      const config = await ensureLoggedIn({ ...DEFAULTS }, chalk);
+      console.log(chalk.dim(`  Run ${chalk.cyan('badgr run python train.py')} to launch your first job.\n`));
+      return config;
+    }
+
+    console.error(chalk.red('\n  ✗ --key <value> is required in non-interactive mode.\n'));
+    console.error(chalk.dim(`  Get an API key: ${API_KEYS_URL}`));
+    console.error(chalk.dim('  Example: badgr login --key bdgr_...\n'));
+    process.exitCode = 1;
+    return null;
+  }
+
+  const apiKey = flags.key.trim();
+  if (!apiKey) {
+    console.error(chalk.red('\n  ✗ API key is required.\n'));
+    process.exitCode = 1;
+    return null;
+  }
 
-  // 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'));
+    await callApi('/models', { apiKey, baseUrl: DEFAULTS.baseUrl });
   } 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.error(chalk.red('\n  ✗ That API key was rejected — not saved.'));
+      console.error(chalk.dim(`  Get a valid key: ${API_KEYS_URL}\n`));
+      process.exitCode = 1;
+      return null;
     }
+    console.log(chalk.yellow('\n  ⚠ Could not reach the API to verify the key right now — saving anyway.'));
   }
 
+  const config = saveConfigFn({ apiKey, baseUrl: DEFAULTS.baseUrl });
+
+  console.log(chalk.green('\n✓ Logged in'));
+  console.log(chalk.dim(`  Config saved to ~/.badgr/config.json`));
   console.log(chalk.dim(`  Run ${chalk.cyan('badgr run python train.py')} to launch your first job.\n`));
   return config;
 }

package/src/commands/run.js

@@ -8,10 +8,11 @@ import { addReceipt, updateReceipt, generateReceiptId, selectedComputeFromDeploy
 import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
 import { formatCliError } from '../errors.js';
 import { TEMPLATE_MAP, buildTemplateFlags, parseTemplateOverrides } from '../catalog.js';
-import { stage as _stage, stageDone as _stageDone, writeBlock as _writeBlock, clearBlock as _clearBlock, renderLiveBlock as _renderLiveBlock, printFailureClass as _printFailureClass } from '../progress.js';
+import { stage as _stage, stageDone as _stageDone, writeBlock as _writeBlock, clearBlock as _clearBlock, renderLiveBlock as _renderLiveBlock, printFailureClass as _printFailureClass, printCapacityPreview, formatTierLabel } from '../progress.js';
 import { detectWorkload, workloadTypeLabel } from '../detect.js';
 import { ensureBadgrReady } from '../onboarding.js';
 import { VM_CLASSES, parseGbSize } from '../spec.js';
+import { parseEnvFlag } from '../envFlag.js';
 
 function vmClassLine(sizeKey) {
   const vmClass = VM_CLASSES[sizeKey];
@@ -98,15 +99,6 @@ export function parseRunArgs(args) {
   return { flags, positional, commandArgv };
 }
 
-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;
-}
-
 // Heuristic for --env keys that look like secrets — used to warn (not
 // block) since there is no dashboard --profile injection path yet and
 // --env is currently the only way to get a provider key into a launch VM.
@@ -458,7 +450,10 @@ async function _zipDirectory(dirPath, chalk) {
     throw new Error(`Directory not found: ${absDir}`);
   }
 
-  const tmpFile = path.join(os.tmpdir(), `badgr-upload-${Date.now()}.zip`);
+  // Random suffix (not just Date.now()) avoids two concurrent zips
+  // (e.g. a real upload racing a --dry-run size estimate) colliding on the
+  // same filename within the same millisecond.
+  const tmpFile = path.join(os.tmpdir(), `badgr-upload-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.zip`);
 
   const { default: archiver } = await import('archiver');
   await new Promise((resolve, reject) => {
@@ -478,6 +473,18 @@ async function _zipDirectory(dirPath, chalk) {
   return tmpFile;
 }
 
+// Local-only size estimate for a dry run: zips the project exactly like a
+// real upload would, measures it, then deletes the temp file — no network
+// call, no uploadBlob, so `--dry-run` never actually uploads the project.
+async function _estimateUploadSizeMb(dirPath) {
+  const tmpFile = await _zipDirectory(dirPath);
+  try {
+    return (fs.statSync(tmpFile).size / 1024 / 1024).toFixed(1);
+  } finally {
+    fs.unlinkSync(tmpFile);
+  }
+}
+
 export async function _uploadCodeZip(config, dirPath, chalk) {
   process.stdout.write(chalk.dim('  Packing project...'));
   const tmpFile = await _zipDirectory(dirPath, chalk);
@@ -775,6 +782,12 @@ export async function runCommand(config, args, chalk, opts = {}) {
     console.log(`  ${chalk.bold(isLaunch || flags.noGpu ? 'Compute:' : 'GPU:')}      ${isLaunch || flags.noGpu ? 'CPU VM (no GPU)' : (gpu || chalk.dim('auto'))}`);
     if (isLaunch && flags.size) console.log(`  ${chalk.bold('VM class:')}     ${vmClassLine(flags.size)}`);
     if (isLaunch && quotedRate != null) console.log(`  ${chalk.bold('Badgr rate:')}   $${quotedRate.toFixed(2)}/hour`);
+    if (isLaunch && flags.authRequired?.provider) {
+      const authLine = flags.authRequired.status === 'connected'
+        ? chalk.green(`${flags.authRequired.provider} connected`)
+        : chalk.yellow(`${flags.authRequired.provider} not connected — will prompt (or run: badgr connect ${flags.authRequired.provider})`);
+      console.log(`  ${chalk.bold('Auth:')}         ${authLine}`);
+    }
     if (flags.minVram)    console.log(`  ${chalk.bold('Min VRAM:')}     ${flags.minVram} GB`);
     if (flags.cpu)        console.log(`  ${chalk.bold('CPU:')}          ${flags.cpu} cores`);
     if (flags.memory)     console.log(`  ${chalk.bold('Memory:')}       ${flags.memory} GB`);
@@ -787,7 +800,27 @@ export async function runCommand(config, args, chalk, opts = {}) {
     if (flags.retrySafe)  console.log(`  ${chalk.bold('Retry-safe:')}   enabled`);
     if (flags.resumeCmd)  console.log(`  ${chalk.bold('Resume cmd:')}   ${flags.resumeCmd}`);
     if (flags.artifacts?.length) console.log(`  ${chalk.bold('Artifacts:')}    ${flags.artifacts.join(', ')}`);
-    console.log(chalk.dim('\n  Remove --dry-run to provision.\n'));
+    if (!isLaunch) console.log(`  ${chalk.bold('Tier:')}         ${formatTierLabel(effectiveTier)}`);
+
+    // Upload-size estimate is GPU-job-specific (spec: "badgr run ... upload
+    // size") and does a real local zip pass — skip it for CPU launches
+    // (badgr launch always sources from '.'), where it would add a real,
+    // possibly-slow filesystem operation to every dry-run preview for no
+    // requested benefit.
+    if (isLocalPath && !isLaunch) {
+      try {
+        const sizeMb = await _estimateUploadSizeMb(path.resolve(firstArg));
+        console.log(`  ${chalk.bold('Upload size:')}  ~${sizeMb} MB (not uploaded)`);
+      } catch (err) {
+        console.log(chalk.dim(`  Upload size: could not estimate (${err.message})`));
+      }
+    }
+
+    console.log();
+    if (!isLaunch && !flags.noGpu) {
+      await printCapacityPreview(chalk, config, { gpu, region: flags.region?.toUpperCase(), maxPrice: flags.maxPrice });
+    }
+    console.log(chalk.dim('  Remove --dry-run to provision.\n'));
     return;
   }
 
@@ -824,7 +857,6 @@ export async function runCommand(config, args, chalk, opts = {}) {
   if (flags.artifacts?.length) console.log(`  ${chalk.bold('Artifacts:')}  ${flags.artifacts.join(', ')}`);
   console.log();
 
-
   // Resolve --workspace name → ws_… ID before submitting
   let resolvedWorkspaceId = flags.workspace ?? null;
   if (resolvedWorkspaceId && !resolvedWorkspaceId.startsWith('ws_')) {

package/src/commands/sbatch.js

@@ -22,6 +22,7 @@ import { normalizeGpuType } from '../spec.js';
 import { monitorBatchJob, fmtRuntime } from '../batch.js';
 import { runFanOut, DEFAULT_CONCURRENCY } from '../fanout.js';
 import { callApi } from '../api.js';
+import { printCapacityPreview } from '../progress.js';
 
 const DEFAULT_IMAGE = 'python:3.11-slim';
 const DEFAULT_MAX_RUNTIME_MIN = 60;
@@ -153,9 +154,13 @@ export async function sbatchCommand(config, args, chalk) {
   const taskIds = isArray ? job.arrayIndices : [null];
   const concurrency = flags.maxConcurrency ?? DEFAULT_CONCURRENCY;
 
+  const resolvedGpu = job.gpuCount > 0 ? (job.gpuType ? normalizeGpuType(job.gpuType) : 'AUTO') : 'NONE';
+
   if (flags.dryRun) {
+    requireApiKey(config);
     console.log(chalk.dim(`  Dry run — no GPU provisioned. Would submit ${taskIds.length} job(s) (max ${Math.min(concurrency, taskIds.length)} concurrent) with:`));
-    console.log(chalk.dim(`  image=${opts.image} tier=${opts.tier} max_cost=$${opts.maxCostUsd} max_runtime=${opts.maxRuntimeMinutes}min\n`));
+    console.log(chalk.dim(`  image=${opts.image} gpu=${resolvedGpu} tier=${opts.tier} max_cost=$${opts.maxCostUsd} max_runtime=${opts.maxRuntimeMinutes}min\n`));
+    if (resolvedGpu !== 'NONE') await printCapacityPreview(chalk, config, { gpu: resolvedGpu, region: opts.region?.toUpperCase(), maxPrice: undefined });
     return;
   }
 

package/src/commands/serve.js

@@ -3,8 +3,10 @@ import { callApi, listDeployments } from '../api.js';
 import { addDeployment, addReceipt, updateReceipt, generateReceiptId } from '../store.js';
 import { normalizeTier, callWithFallback } from '../fallback.js';
 import { formatCliError } from '../errors.js';
+import { requireApiKey } from '../config.js';
+import { parseEnvFlag } from '../envFlag.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, printFailureClass as _printFailureClass } from '../progress.js';
+import { stage as _stage, stageDone as _stageDone, writeBlock as _writeBlock, clearBlock as _clearBlock, renderLiveBlock as _renderLiveBlock, printFailureClass as _printFailureClass, printCapacityPreview, formatTierLabel } from '../progress.js';
 
 const LLAMA_CPP_IMAGE = 'michaelmanleyx/llama-cpp:server-cuda';
 
@@ -45,6 +47,7 @@ export function parseServeArgs(args) {
     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] === '--dry-run')      { flags.dryRun = true; i++; continue; }
     if (args[i] === '--env') {
       const kv = args[++i]; i++;
       if (!flags.env) flags.env = [];
@@ -57,15 +60,6 @@ export function parseServeArgs(args) {
   return { model, flags };
 }
 
-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;
-}
-
 function envObjHasHfToken(envList) {
   return (envList || []).some(kv => kv.startsWith('HF_TOKEN='));
 }
@@ -122,6 +116,17 @@ function _detectHealthPath(image) {
   return null;
 }
 
+// Priority: explicit --health-path > llama.cpp → /health > task-specific >
+// vLLM → /models > auto-detect custom image > null. Pure (no `dep` needed),
+// so both the dry-run preview and the real post-launch health check use the
+// exact same resolution and can never show a different path than they poll.
+function _resolveHealthPath({ healthPath, isLlamaCpp, customImage, task }) {
+  if (healthPath) return healthPath;
+  if (isLlamaCpp) return '/health';
+  if (!customImage) return (task === 'transcribe' || task === 'image') ? '/health' : '/models';
+  return _detectHealthPath(customImage); // '/system_stats' for comfyui, null otherwise
+}
+
 /**
  * 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
@@ -211,7 +216,7 @@ const _KNOWN_SERVE_FLAGS = new Set([
   '--gpu', '--image', '--task', '--count', '--region', '--tier', '--max-price',
   '--name', '--no-wait', '--max-cost', '--idle-timeout', '--health-path', '--check-nodes',
   '--no-fallback', '--strict-capacity', '--no-expanded-search', '--env',
-  '--persistent', '--yes', '-y', '--runtime', '--hf-repo', '--hf-file',
+  '--persistent', '--yes', '-y', '--runtime', '--hf-repo', '--hf-file', '--dry-run',
 ]);
 
 function extractFlag(args, flagName) {
@@ -396,7 +401,14 @@ export async function serveCommand(config, args, chalk) {
     return;
   }
 
-  config = await ensureBadgrReady(config, chalk);
+  // A dry run previews the plan only and never provisions or spends anything,
+  // so it doesn't need the interactive browser login — just a stored key, to
+  // keep its existing fail-fast behavior in non-interactive contexts (tests/CI).
+  if (flags.dryRun) {
+    requireApiKey(config);
+  } else {
+    config = await ensureBadgrReady(config, chalk);
+  }
 
   // ── Validate flags early ───────────────────────────────────────────────────
   if (flags.count !== undefined && (!Number.isFinite(flags.count) || flags.count < 1)) {
@@ -416,7 +428,7 @@ export async function serveCommand(config, args, chalk) {
   }
 
   // Endpoints bill continuously — require explicit cost control.
-  if (!flags.maxCost && !flags.persistent) {
+  if (!flags.maxCost && !flags.persistent && !flags.dryRun) {
     const example = model || (customImage ? '--image ...' : '<model>');
     console.error(chalk.red('\n  ✗ Endpoints bill continuously until stopped. Specify a spending limit:\n'));
     console.error(chalk.dim(`    --max-cost 5           auto-stop when $5 is reached`));
@@ -469,8 +481,15 @@ export async function serveCommand(config, args, chalk) {
   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(', ')]);
+  if (flags.dryRun) {
+    headerLines.push(['Tier', formatTierLabel(effectiveTier)]);
+    const previewHealthPath = _resolveHealthPath({ healthPath: flags.healthPath, isLlamaCpp, customImage, task: flags.task });
+    headerLines.push(['Health path', previewHealthPath || chalk.dim('none (custom image, unset)')]);
+  }
 
-  console.log(chalk.bold(`\n⚡ Serving ${title}\n`));
+  console.log(chalk.bold(flags.dryRun
+    ? `\n⚡ Dry run — no GPU will be provisioned — ${title}\n`
+    : `\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}`);
@@ -488,6 +507,16 @@ export async function serveCommand(config, args, chalk) {
   }
   console.log();
 
+  if (flags.dryRun) {
+    await printCapacityPreview(chalk, config, {
+      gpu,
+      region: flags.region ? flags.region.toUpperCase() : undefined,
+      maxPrice: flags.maxPrice,
+    });
+    console.log(chalk.dim('  Remove --dry-run to provision.\n'));
+    return;
+  }
+
   const STAGE_TOTAL = 5;
   let stageN = 1;
 
@@ -620,22 +649,7 @@ export async function serveCommand(config, args, chalk) {
   }
 
   // ── Determine health check path ───────────────────────────────────────────
-  // Priority: explicit --health-path > llama.cpp → /health > task-specific > vLLM → /models > auto-detect custom image > null
-  let resolvedHealthPath;
-  if (flags.healthPath) {
-    resolvedHealthPath = flags.healthPath;
-  } else if (isLlamaCpp) {
-    resolvedHealthPath = '/health';
-  } else if (!customImage) {
-    // Managed runtimes for transcribe/image expose /health; vLLM (chat, embed) uses /models
-    if (flags.task === 'transcribe' || flags.task === 'image') {
-      resolvedHealthPath = '/health';
-    } else {
-      resolvedHealthPath = '/models';
-    }
-  } else {
-    resolvedHealthPath = _detectHealthPath(customImage);  // '/system_stats' for comfyui, null otherwise
-  }
+  const resolvedHealthPath = _resolveHealthPath({ healthPath: flags.healthPath, isLlamaCpp, customImage, task: flags.task });
 
   // Gated-model guidance is only shown when it's actually needed — on failure —
   // not up front, so common launches stay short and uncluttered.

package/src/commands/train.js

@@ -10,8 +10,9 @@ import { requireApiKey } from '../config.js';
 import { addReceipt, updateReceipt, generateReceiptId } from '../store.js';
 import { normalizeTier, callWithFallback } from '../fallback.js';
 import { monitorBatchJob, fmtRuntime } from '../batch.js';
-import { pollJobUntilTerminal, renderJobClosingBlock } from '../progress.js';
+import { pollJobUntilTerminal, renderJobClosingBlock, printCapacityPreview, formatTierLabel } from '../progress.js';
 import { uploadBlob } from '../api.js';
+import { parseEnvFlag } from '../envFlag.js';
 
 const MAX_CONFIG_B = 512 * 1024; // 512 KB config limit
 
@@ -64,15 +65,6 @@ export function parseTrainArgs(args) {
   return { configFile: positional[0] || null, flags };
 }
 
-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;
-}
-
 /**
  * Detect training framework from config content.
  * Returns 'axolotl' | 'unsloth' | 'trl' | 'generic'.
@@ -155,20 +147,24 @@ export async function trainLoraCommand(config, args, chalk) {
   if (flags.dryRun) {
     const preset = flags.preset || 'small';
     const presetInfo = LORA_PRESET_INFO[preset];
+    const resolvedGpu = flags.gpuType || presetInfo?.gpu_type;
     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('GPU:')}          ${resolvedGpu}`);
       console.log(`  ${chalk.bold('LoRA rank:')}    ${presetInfo.rank}`);
       console.log(`  ${chalk.bold('Epochs:')}       ${presetInfo.epochs}`);
       console.log(`  ${chalk.dim(presetInfo.description)}`);
     }
+    console.log(`  ${chalk.bold('Tier:')}         ${formatTierLabel(normalizeTier(flags.tier))}`);
     if (flags.maxCost)    console.log(`  ${chalk.bold('Max cost:')}     $${flags.maxCost}`);
     console.log(`  ${chalk.bold('Max runtime:')}  ${flags.maxRuntime ?? 240}min`);
     if (flags.resume)    console.log(`  ${chalk.bold('Resume from:')}  ${flags.resume}`);
-    console.log(chalk.dim('\n  Remove --dry-run to submit (local file datasets are uploaded first).\n'));
+    console.log();
+    if (resolvedGpu) await printCapacityPreview(chalk, config, { gpu: resolvedGpu });
+    console.log(chalk.dim('  Remove --dry-run to submit (local file datasets are uploaded first).\n'));
     return;
   }