badgr-cli 1.1.1 → 1.1.3

package/src/commands/run.js

@@ -5,13 +5,14 @@ import { createWriteStream } from 'fs';
 import { requireApiKey } from '../config.js';
 import { callApi, terminateDeployment, uploadBlob, quoteRun } from '../api.js';
 import { addReceipt, updateReceipt, generateReceiptId, selectedComputeFromDeployment } from '../store.js';
-import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
+import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD, SMOKE_MAX_COST_USD, SMOKE_MAX_RUNTIME_MINUTES } 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];
@@ -56,6 +57,7 @@ export function parseRunArgs(args) {
     if (flagArgs[i] === '--count')          { flags.count = parseInt(flagArgs[++i], 10); i++; continue; }
     if (flagArgs[i] === '--region')         { flags.region = flagArgs[++i]; i++; continue; }
     if (flagArgs[i] === '--tier')           { flags.tier = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--smoke')          { flags.smoke = true; i++; continue; }
     if (flagArgs[i] === '--max-price')      { flags.maxPrice = parseFloat(flagArgs[++i]); i++; continue; }
     if (flagArgs[i] === '--name')           { flags.name = flagArgs[++i]; i++; continue; }
     if (flagArgs[i] === '--detach')          { flags.detach = true; i++; continue; }
@@ -98,15 +100,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.
@@ -417,7 +410,7 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
 
 // Known badgr run flags — used to detect broken shell line continuation.
 const _KNOWN_RUN_FLAGS = new Set([
-  '--gpu', '--image', '--count', '--region', '--tier', '--max-price', '--name',
+  '--gpu', '--image', '--count', '--region', '--tier', '--smoke', '--max-price', '--name',
   '--detach', '--no-detach', '--fallback', '--no-fallback', '--strict-capacity',
   '--no-expanded-search', '--max-runtime', '--max-cost', '--min-vram', '--gpu-memory',
   '--cpu', '--memory', '--no-gpu', '--env',
@@ -458,7 +451,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 +474,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);
@@ -685,6 +693,28 @@ export async function runCommand(config, args, chalk, opts = {}) {
     return;
   }
 
+  // ── Smoke mode: cheapest compatible provider for local/dev test runs ──────
+  // --smoke, or BADGR_DEV_CHEAPEST=1 in the environment for a local default so
+  // it doesn't have to be typed every time. An explicit --tier always wins —
+  // the user asked for a specific tier, so smoke's routing/caps don't apply.
+  const devCheapestEnv = process.env.BADGR_DEV_CHEAPEST === '1' || process.env.BADGR_DEV_CHEAPEST === 'true';
+  const smokeMode = !flags.tier && (flags.smoke || devCheapestEnv);
+
+  if (smokeMode) {
+    if (flags.detach) {
+      console.error(chalk.red('  ✗ --smoke requires teardown to run in the foreground — remove --detach.'));
+      process.exitCode = 1;
+      return;
+    }
+    if (flags.workspace) {
+      console.error(chalk.red('  ✗ --smoke does not support --workspace (no persistent storage for smoke runs).'));
+      process.exitCode = 1;
+      return;
+    }
+    if (flags.maxCost === undefined) flags.maxCost = SMOKE_MAX_COST_USD;
+    if (flags.maxRuntime === undefined) flags.maxRuntime = SMOKE_MAX_RUNTIME_MINUTES;
+  }
+
   if (!flags.maxCost && !flags.dryRun && isLocalPath && process.stdin.isTTY && process.stdout.isTTY) {
     try {
       const { input } = await import('@inquirer/prompts');
@@ -775,6 +805,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 +823,28 @@ 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)}`);
+    if (smokeMode)  console.log(`  ${chalk.bold('Routing:')}      cheapest compatible (smoke mode)`);
+
+    // 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;
   }
 
@@ -815,6 +872,7 @@ export async function runCommand(config, args, chalk, opts = {}) {
   console.log(`  ${chalk.bold('Max cost:')}    ${maxCostLabel}`);
   console.log(`  ${chalk.bold('Max runtime:')} ${runtimeLabel}`);
   console.log(`  ${chalk.bold('Auto-stop:')}   ${maxCost ? 'enabled' : chalk.yellow('disabled — stop manually with badgr down')}`);
+  if (smokeMode) console.log(`  ${chalk.bold('Routing:')}     cheapest compatible (smoke mode)`);
   if (flags.maxPrice) console.log(`  ${chalk.bold('Max price:')}   $${flags.maxPrice.toFixed(2)}/hr`);
   if (detach)         console.log(`  ${chalk.dim('(detached — returns immediately)')}`);
   if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}      ${redactEnvForDisplay(flags.env)}`);
@@ -824,7 +882,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_')) {
@@ -880,6 +937,7 @@ export async function runCommand(config, args, chalk, opts = {}) {
       max_price_per_hour: flags.maxPrice,
       name: flags.name,
       tier: tierOverride || effectiveTier,
+      ...(smokeMode ? { routing: 'cheapest' } : {}),
       ...(Object.keys(envObj).length > 0 ? { env: envObj } : {}),
       max_runtime_seconds: effectiveMaxRuntime * 60,
       ...(maxCost ? { max_cost_usd: maxCost } : {}),
@@ -904,7 +962,7 @@ export async function runCommand(config, args, chalk, opts = {}) {
       effectiveTier,
       chalk,
       { thing: 'job', cmd: cmdName },
-      { allowTier2Fallback: !flags.noFallback },
+      { allowTier2Fallback: !flags.noFallback, singleAttempt: smokeMode },
     );
   } catch (err) {
     if (err.isPaymentRequired) {

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;
   }
 

package/src/commands/transcribe.js

@@ -10,6 +10,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 WHISPER_IMAGE        = 'fedirz/faster-whisper-server:latest-cuda';
 const DEFAULT_WHISPER_MODEL = 'large-v3';
@@ -32,6 +34,7 @@ export function parseTranscribeArgs(args) {
     if (a === '--language')    { flags.language = args[++i]; i++; continue; }
     if (a === '--output')      { flags.output = args[++i]; 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 = [];
@@ -43,15 +46,6 @@ export function parseTranscribeArgs(args) {
   return { input: 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;
-}
-
 function isUrl(s) {
   return /^(https?|s3|gs|hf):\/\//i.test(s);
 }
@@ -116,15 +110,24 @@ export async function transcribeCommand(config, args, chalk) {
     ...(flags.output       ? { WHISPER_OUTPUT_FORMAT: flags.output } : {}),
   };
 
-  console.log(chalk.bold('\n🎙 Transcription\n'));
+  console.log(chalk.bold(flags.dryRun ? '\n🎙 Dry run — no GPU will be provisioned — Transcription\n' : '\n🎙 Transcription\n'));
   console.log(`  ${chalk.bold('Input:')}       ${resolved.inputLabel}`);
   console.log(`  ${chalk.bold('Model:')}       ${whisperModel}`);
   console.log(`  ${chalk.bold('Image:')}       ${WHISPER_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.language) console.log(`  ${chalk.bold('Language:')}    ${flags.language}`);
+  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/credentials.js

@@ -8,10 +8,43 @@ export const CREDENTIALS_FILE = join(CONFIG_DIR, 'credentials.json');
 export const PROVIDER_ENV_KEYS = {
   anthropic: 'ANTHROPIC_API_KEY',
   openai: 'OPENAI_API_KEY',
+  // OpenAI-compatible BYOK lanes for `badgr launch cline --provider <name>`
+  // (see MODEL_PROVIDERS below) — the cline agent image only ever reads
+  // OPENAI_API_KEY/OPENAI_BASE_URL/MODEL (images/badgr-agent-cline/
+  // badgr-cline-run), regardless of which upstream provider the key
+  // actually belongs to.
+  openrouter: 'OPENAI_API_KEY',
+  deepseek: 'OPENAI_API_KEY',
+  glm: 'OPENAI_API_KEY',
+  custom: 'OPENAI_API_KEY',
 };
 
 export const KNOWN_PROVIDERS = Object.keys(PROVIDER_ENV_KEYS);
 
+// `badgr launch cline --provider <name> --model <id> [--base-url <url>]` —
+// BYOK / OpenAI-compatible model selection. `custom` has no default base
+// URL: it must always be supplied explicitly, since there is nothing sane
+// to default it to. Every other entry's defaultBaseUrl is overridable with
+// an explicit --base-url too (e.g. a company-hosted DeepSeek-compatible
+// gateway).
+export const MODEL_PROVIDERS = {
+  openrouter: { label: 'OpenRouter', defaultBaseUrl: 'https://openrouter.ai/api/v1' },
+  deepseek: { label: 'DeepSeek', defaultBaseUrl: 'https://api.deepseek.com/v1' },
+  glm: { label: 'GLM (Zhipu)', defaultBaseUrl: 'https://open.bigmodel.cn/api/paas/v4' },
+  custom: { label: 'Custom (OpenAI-compatible)', defaultBaseUrl: null },
+};
+
+export const KNOWN_MODEL_PROVIDERS = Object.keys(MODEL_PROVIDERS);
+
+// Which env vars each API kind expects inside the agent container.
+// `claude` uses the Anthropic SDK (ANTHROPIC_*); `cline` and `codex` use the
+// OpenAI SDK (OPENAI_*). `model` is always 'MODEL' — every agent wrapper
+// reads that env var and maps it to its own --model flag.
+export const ENV_KEYS_FOR_API_KIND = {
+  openai:    { apiKey: 'OPENAI_API_KEY',    baseUrl: 'OPENAI_BASE_URL',    model: 'MODEL' },
+  anthropic: { apiKey: 'ANTHROPIC_API_KEY', baseUrl: 'ANTHROPIC_BASE_URL', model: 'MODEL' },
+};
+
 /**
  * Credential storage for `badgr connect <provider>`. This is a local file
  * under ~/.badgr with owner-only permissions (chmod 600) — not the

package/src/envFlag.js

@@ -0,0 +1,10 @@
+// Shared by every command that accepts repeated `--env KEY=VALUE` flags
+// (run, serve, comfyui, train, transcribe, embed).
+export 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;
+}

package/src/fallback.js

@@ -6,6 +6,13 @@ import { CATALOG, formatCliError } from './errors.js';
 /** Rates above this threshold trigger a visible warning when no --max-cost is set. */
 export const HIGH_RATE_THRESHOLD = 3.00;
 
+// ── badgr run --smoke defaults ────────────────────────────────────────────────
+// Hardcoded default smoke caps, not a config system — --max-cost/--max-runtime
+// still override them when passed explicitly (see run.js). The goal is to stop
+// expensive local smoke tests by default, not build another configuration system.
+export const SMOKE_MAX_COST_USD = 0.25;
+export const SMOKE_MAX_RUNTIME_MINUTES = 10;
+
 /** Normalise --tier flag variants to '1' or '2'. */
 export function normalizeTier(tier) {
   return (tier === '2' || tier === 'tier2' || tier === 'tier-2') ? '2' : (tier || '1');
@@ -37,12 +44,16 @@ export class CapacityError extends Error {
  * @param {object}   labels            - { thing: 'job'|'endpoint', cmd: 'badgr run'|'badgr serve' }
  * @param {object}   [opts]
  * @param {boolean}  [opts.allowTier2Fallback=true] - set false to disable tier-2 expansion
+ * @param {boolean}  [opts.singleAttempt=false] - set true to skip both the same-tier
+ *   provider retry and tier-2 expansion, failing immediately on the first error
+ *   (badgr run --smoke's "one attempt" guarantee)
  */
 export async function callWithFallback(endpoint, callOpts, buildBody, effectiveTier, chalk, labels, opts = {}) {
   const { callApi } = await import('./api.js');
   const thing = labels?.thing ?? 'job';
   const cmd   = labels?.cmd   ?? 'badgr run';
-  const allowTier2Fallback = opts.allowTier2Fallback !== false; // default true
+  const singleAttempt = opts.singleAttempt === true;
+  const allowTier2Fallback = !singleAttempt && opts.allowTier2Fallback !== false; // default true
 
   // 220s: comfortably above backend's BADGR_PROVISION_TIMEOUT_SECONDS (default
   // 200s, itself set above deployment_service.py's 180s routing-search
@@ -113,7 +124,7 @@ export async function callWithFallback(endpoint, callOpts, buildBody, effectiveT
   // Provider retry: PROVISIONING_FAILED means the selected provider couldn't launch the slot.
   // Retry once with prefer_different_provider so the backend routes to a different provider
   // (e.g. RunPod failed → try Vast.ai or Hyperstack) within the same max_cost budget.
-  if (d?.code === 'PROVISIONING_FAILED' || d?.code === 'PROVIDER_ADAPTER_ERROR') {
+  if (!singleAttempt && (d?.code === 'PROVISIONING_FAILED' || d?.code === 'PROVIDER_ADAPTER_ERROR')) {
     console.log(chalk.dim('\n  Provider unavailable — trying alternative provider...\n'));
     try {
       const retryBody = { ...buildBody(), prefer_different_provider: true };

package/src/onboarding.js

@@ -50,7 +50,14 @@ async function pollCliSession(config, sessionId) {
   throw new Error('Timed out waiting for login in the browser. Run `badgr login` directly.');
 }
 
-async function ensureLoggedIn(config, chalk) {
+/**
+ * Opens the browser-based login link and polls until it completes, saving
+ * the returned API key. Exported so `badgr login` (an explicit, standalone
+ * invocation) can reuse the exact same flow `ensureBadgrReady` triggers
+ * just-in-time from `run`/`launch`/`serve`/`comfyui`, rather than having a
+ * second, divergent login implementation.
+ */
+export async function ensureLoggedIn(config, chalk) {
   console.log(chalk.dim("\n  You're not logged in to Badgr."));
   console.log(chalk.dim('  Badgr uses prepaid credits to pay for the VM and model usage.\n'));
 

package/src/progress.js

@@ -2,6 +2,8 @@
 // numbered stage lines plus an in-place-redrawing status block, so neither
 // command spams repeated identical loading lines.
 
+import { getCapacityPreview } from './api.js';
+
 export function stage(n, total, label) {
   return `  [${n}/${total}] ${label}`;
 }
@@ -200,3 +202,49 @@ export function renderJobClosingBlock(chalk, detail, rcptId) {
 
   return lines.join('\n') + '\n';
 }
+
+// Shared across every dry-run preview that shows routing tier — normalizeTier()
+// already collapses anything else to 1, so this only ever distinguishes 1 vs 2.
+export function formatTierLabel(tier) {
+  return tier === 2 ? '2 (marketplace)' : '1 (managed)';
+}
+
+/**
+ * Shared "live capacity preview" block for GPU-provisioning dry runs
+ * (badgr serve/run/comfyui/train/batch/sbatch --dry-run). Calls the
+ * no-provisioning GET /v1/capacity/suggestions route (api.js's
+ * getCapacityPreview) and prints an observed rate/alternatives — same shape
+ * `badgr up --dry-run` already showed, now reused everywhere else instead of
+ * every dry-run only echoing back the flags the user typed. Best-effort:
+ * a failed or empty lookup prints a one-line fallback, never blocks or
+ * throws, since a dry run must always finish even if live pricing can't be
+ * reached (offline, GPU not currently listed, transient API error, etc).
+ */
+export async function printCapacityPreview(chalk, config, { gpu, region, maxPrice }) {
+  if (!gpu || gpu === 'AUTO' || gpu === 'NONE') {
+    console.log(chalk.dim(`  GPU is auto-selected — resolved to a specific type and priced at provision time.`));
+    console.log();
+    return;
+  }
+  try {
+    const suggestions = await getCapacityPreview(config, { gpu, region, maxPrice });
+    const matches = suggestions?.matches ?? suggestions?.routes ?? [];
+    const alternatives = suggestions?.alternatives ?? [];
+    console.log(chalk.bold('  Live capacity'));
+    if (matches.length === 0) {
+      console.log(chalk.yellow(`  No ${gpu} capacity found right now`));
+    } else {
+      const cheapest = matches[0];
+      console.log(`  ${chalk.cyan(gpu)} available — from ${chalk.green('$' + cheapest.price.toFixed(2) + '/hr')} (${matches.length} offer(s), tier ${cheapest.tier})`);
+    }
+    if (alternatives.length > 0) {
+      alternatives.slice(0, 2).forEach(a => {
+        console.log(chalk.dim(`    alt: ${a.gpu} in ${a.region}  $${a.price.toFixed(2)}/hr${a.diff_desc ? ` — ${a.diff_desc}` : ''}`));
+      });
+    }
+    console.log();
+  } catch (err) {
+    console.log(chalk.dim(`  Live capacity: could not fetch (${err.message})`));
+    console.log();
+  }
+}