badgr-cli 1.1.1 → 1.1.2

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

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/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/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();
+  }
+}

package/tests/agent-images.test.js

@@ -1,17 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { readFileSync } from 'fs';
-import { resolve } from 'path';
-
-const root = resolve(import.meta.dirname, '../../..');
-
-describe('Phase 1 agent runtime images', () => {
-  it.each([
-    ['claude', 'images/badgr-agent-claude/Dockerfile', '@anthropic-ai/claude-code'],
-    ['codex', 'images/badgr-agent-codex/Dockerfile', '@openai/codex'],
-    ['opencode', 'images/badgr-agent-opencode/Dockerfile', 'opencode-ai'],
-  ])('%s image extends the Badgr job runner and installs the CLI', (_name, file, pkg) => {
-    const text = readFileSync(resolve(root, file), 'utf8');
-    expect(text).toContain('badgr-job-runner');
-    expect(text).toContain(pkg);
-  });
-});