badgr-cli 1.1.1 → 1.1.3

package/src/commands/connect.js

@@ -79,5 +79,8 @@ export async function connectCommand(args, chalk, deps = {}) {
   setCredential(provider, key);
   console.log(chalk.green(`\n  ✓ ${alreadyConnected ? 'Updated' : 'Connected'} ${provider}`));
   console.log(chalk.dim(`  Stored in ${CREDENTIALS_FILE} (owner-only file permissions)`));
-  console.log(chalk.dim(`  Used automatically by: badgr launch ${provider === 'anthropic' ? 'claude' : provider === 'openai' ? 'codex' : provider} "<task>"\n`));
+  const usageHint = provider === 'anthropic' ? 'badgr launch claude "<task>"'
+    : provider === 'openai' ? 'badgr launch codex "<task>"'
+    : `badgr launch cline/claude/codex --provider ${provider} --model <model-id> "<task>"`;
+  console.log(chalk.dim(`  Used automatically by: ${usageHint}\n`));
 }

package/src/commands/diagnose.js

@@ -0,0 +1,493 @@
+import fs from 'fs';
+import { callApi } from '../api.js';
+import { ensureLoggedIn } from '../onboarding.js';
+
+const DIAGNOSE_HELP = `
+Paste anything. Badgr detects the input, diagnoses it for free, then
+shows either missing information, a verified template, or a capped
+smoke-test plan. No GPU launches without explicit --approve.
+
+Usage:
+  badgr diagnose "<input>"
+  badgr diagnose "<input>" --approve
+  badgr diagnose "<input>" --json
+  badgr diagnose <case_id_or_url> --approve   Resume an existing case (e.g.
+                                               one shared via a case link)
+
+Input (auto-detected):
+  GitHub issue URL       https://github.com/org/repo/issues/N
+  GitHub repo URL        https://github.com/org/repo
+  Docker image           owner/image:tag  or  image:tag
+  Local log / file       ./error.log  or  vllm.log
+  ComfyUI workflow       workflow.json  (JSON file)
+  Raw conversation       paste Discord / Slack / support thread text
+  Existing case          repro_xxxxxxxx  or  https://aibadgr.com/repro/repro_xxxxxxxx
+
+Flags:
+  --approve              Approve the capped smoke test after diagnosis (opens
+                          browser sign-in automatically if not logged in)
+  --docker <image>       Force Docker-image intake (override auto-detect)
+  --repo   <url>         Force repository intake (override auto-detect)
+  --comfyui <path>       Force ComfyUI workflow intake (override auto-detect)
+  --github <url>         Include a GitHub issue URL found inside pasted text
+                          as additional context. Opt-in only, never fetched
+                          automatically (see "Additional context found" below)
+  --json                 Machine-readable JSON output
+  --help, -h             Show this help
+
+Safety: nothing runs from AI-extracted data without --approve.
+        No GPU launches without explicit approval and a credit check.
+
+Full interactive flow: https://aibadgr.com/run-issue`;
+
+function detectInput(raw, flags) {
+  if (flags.docker) {
+    return {
+      kind:  'docker_image',
+      label: `Docker image: ${flags.docker}`,
+      body:  { docker_image: flags.docker },
+    };
+  }
+  if (flags.repo) {
+    return {
+      kind:  'repo_url',
+      label: `GitHub repository: ${flags.repo}`,
+      body:  { repo_url: flags.repo },
+    };
+  }
+  if (flags.comfyui) {
+    if (!fs.existsSync(flags.comfyui)) throw new Error(`File not found: ${flags.comfyui}`);
+    return {
+      kind:  'comfyui_workflow',
+      label: `ComfyUI workflow: ${flags.comfyui}`,
+      body:  { workflow_json: fs.readFileSync(flags.comfyui, 'utf8') },
+    };
+  }
+
+  if (!raw) return null;
+
+  // A case_id (bare, or embedded in a /repro/<id> or /run-issue?case_id=<id>
+  // link — the two shapes an admin-prepared or self-created case gets
+  // shared as) resumes that existing case instead of diagnosing new input.
+  const bareCaseMatch = /^repro_[a-zA-Z0-9]+$/.exec(raw.trim());
+  const urlCaseMatch = /\/repro\/(repro_[a-zA-Z0-9]+)/.exec(raw) || /[?&]case_id=(repro_[a-zA-Z0-9]+)/.exec(raw);
+  const caseId = bareCaseMatch?.[0] || urlCaseMatch?.[1];
+  if (caseId) {
+    return { kind: 'existing_case', label: `Existing case: ${caseId}`, caseId };
+  }
+
+  if (/^https?:\/\/(www\.)?github\.com\/[^/]+\/[^/]+\/issues\/\d/.test(raw)) {
+    return {
+      kind:  'github_issue',
+      label: `GitHub issue: ${raw}`,
+      body:  { github_url: raw },
+    };
+  }
+
+  if (/^https?:\/\/(www\.)?github\.com\//.test(raw)) {
+    return {
+      kind:  'repo_url',
+      label: `GitHub repository: ${raw}`,
+      body:  { repo_url: raw },
+    };
+  }
+
+  if (fs.existsSync(raw)) {
+    const content = fs.readFileSync(raw, 'utf8');
+    if (raw.endsWith('.json') || raw.endsWith('.JSON')) {
+      let parsed;
+      try { parsed = JSON.parse(content); } catch { /* not valid JSON */ }
+      if (parsed && typeof parsed === 'object' && (parsed.nodes || parsed['1'] || parsed['0'])) {
+        return {
+          kind:  'comfyui_workflow',
+          label: `ComfyUI workflow: ${raw}`,
+          body:  { workflow_json: content },
+        };
+      }
+    }
+    return {
+      kind:  'log_file',
+      label: `Log / error file: ${raw}`,
+      body:  { text: content.slice(0, 50_000) },
+    };
+  }
+
+  if (
+    !raw.startsWith('http') &&
+    /^[a-z0-9][a-z0-9._\-]*(?:\/[a-z0-9._\-]+)*(?::[a-zA-Z0-9._\-]+)?$/.test(raw) &&
+    raw.length < 200
+  ) {
+    return {
+      kind:  'docker_image',
+      label: `Docker image: ${raw}`,
+      body:  { docker_image: raw },
+    };
+  }
+
+  return {
+    kind:  'text',
+    label: 'Text / conversation',
+    body:  { text: raw.slice(0, 50_000) },
+  };
+}
+
+function _printResult(result, chalk) {
+  const { extraction: e, static_incompatibilities, multi_gpu_detected, large_download, github_issue, detected_github_url } = result;
+
+  if (github_issue) {
+    console.log(`  ${chalk.bold('Issue:')}   ${github_issue.title}  ${chalk.dim(`[${github_issue.state}]`)}`);
+  }
+
+  // The conversation stays primary — a GitHub URL found inside pasted text
+  // is only ever offered here, never fetched automatically.
+  if (detected_github_url) {
+    console.log();
+    console.log(`  ${chalk.bold('Additional context found:')} ${detected_github_url}`);
+    console.log(`    ${chalk.dim(`Include it: badgr diagnose "<input>" --github ${detected_github_url}`)}`);
+  }
+
+  const wt = e.workload_type && e.workload_type !== 'unknown' ? e.workload_type : null;
+  const conf = e.confidence ? ` ${chalk.dim(`(${Math.round(e.confidence * 100)}% confidence)`)}` : '';
+  if (wt) console.log(`  ${chalk.bold('Workload:')} ${wt}${conf}`);
+  if (e.summary) console.log(`  ${chalk.bold('Summary:')} ${e.summary}`);
+  console.log();
+
+  if (e.docker_images?.length) {
+    console.log(`  ${chalk.bold('Image:')}   ${e.docker_images[0]}${e.docker_images.length > 1 ? chalk.dim(` +${e.docker_images.length - 1} more`) : ''}`);
+  }
+  if (e.models?.length) {
+    console.log(`  ${chalk.bold('Model:')}   ${e.models[0]}${e.models.length > 1 ? chalk.dim(` +${e.models.length - 1} more`) : ''}`);
+  }
+  if (e.commands?.length) {
+    console.log(`  ${chalk.bold('Command:')} ${e.commands[0]}`);
+  }
+  if (e.errors?.length) {
+    console.log(`  ${chalk.bold('Errors:')}`);
+    for (const err of e.errors.slice(0, 3)) console.log(`    ${chalk.red('✗')} ${err}`);
+  }
+
+  if (static_incompatibilities?.length) {
+    console.log();
+    console.log(`  ${chalk.bold('Diagnosis:')} ${chalk.yellow('Static incompatibility — no GPU needed')}`);
+    for (const inc of static_incompatibilities) console.log(`    ${chalk.yellow('!')} ${inc}`);
+  } else if (e.missing_information?.length) {
+    console.log();
+    console.log(`  ${chalk.bold('Diagnosis:')} Missing information`);
+    for (const m of e.missing_information) console.log(`    ${chalk.dim('?')} ${m}`);
+  } else if (wt) {
+    console.log();
+    console.log(`  ${chalk.bold('Diagnosis:')} Workload detected — ready for capped test`);
+  }
+
+  if (multi_gpu_detected) {
+    console.log(`  ${chalk.yellow('!')} Multi-GPU detected: ${multi_gpu_detected}`);
+    console.log(`    ${chalk.dim('Capped test will use a single GPU only.')}`);
+  }
+  if (large_download) {
+    console.log(`  ${chalk.yellow('!')} Large model download: ~${large_download.estimated_gb} GB`);
+    console.log(`    ${chalk.dim('Funding approval required before test launches.')}`);
+  }
+  if (result.secret_types_detected?.length) {
+    console.log(`  ${chalk.dim(`Secrets redacted before analysis: ${result.secret_types_detected.join(', ')}`)}`);
+  }
+  if (!result.ai_available) {
+    console.log(`  ${chalk.dim('(AI extraction unavailable — pattern matching only)')}`);
+  }
+
+  console.log();
+  if (static_incompatibilities?.length) {
+    console.log(`  ${chalk.bold('Recommended action:')} Fix the incompatibility listed above — no GPU test needed`);
+  } else if (e.missing_information?.length) {
+    console.log(`  ${chalk.bold('Recommended action:')} Provide the missing details above, then re-run`);
+  } else {
+    console.log(`  ${chalk.bold('Recommended action:')} Run ${chalk.cyan('badgr diagnose "<input>" --approve')} to launch a capped test`);
+  }
+}
+
+async function _doApprove(config, result, chalk) {
+  // Diagnosis and case creation stay anonymous and free — login is only
+  // required once we know a real GPU test needs approving (below).
+  const e = result.extraction;
+  const confirmBody = {
+    workload_type:              e.workload_type || 'generic',
+    docker_image:               e.docker_images?.[0] || null,
+    model_id:                   e.models?.[0] || null,
+    launch_command:             e.commands?.[0] || null,
+    error_log:                  null,
+    expected_result:            e.expected_result || null,
+    environment_variable_names: e.environment_variable_names || [],
+    gpu_requirements:           Array.isArray(e.gpu_requirements)
+                                  ? e.gpu_requirements.join(', ')
+                                  : e.gpu_requirements || null,
+    source_summary:             e.summary || null,
+  };
+
+  let caseData;
+  try {
+    console.log(chalk.dim('  Creating case...'));
+    caseData = await callApi('/run-issue/confirm', {
+      method:    'POST',
+      apiKey:    config.apiKey || '',
+      baseUrl:   config.baseUrl,
+      body:      confirmBody,
+      timeoutMs: 20_000,
+    });
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ Could not create case: ${err.message}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  const { case_id: caseId, status, test_plan: plan, missing_information: missing } = caseData;
+
+  if (status === 'incompatible') {
+    console.log(chalk.yellow('\n  Static incompatibility — no GPU test needed.'));
+    console.log();
+    return;
+  }
+  if (status === 'missing_information') {
+    console.log(chalk.yellow('\n  Cannot approve — missing information:'));
+    for (const m of (missing || [])) console.log(`    ? ${m}`);
+    console.log();
+    return;
+  }
+  if (status === 'template_matched') {
+    console.log(chalk.green('\n  Matched a verified template — no new GPU test needed.'));
+    if (plan?.final_command) {
+      console.log();
+      console.log(`  ${chalk.bold('Verified command:')}`);
+      console.log(`  ${chalk.cyan(plan.final_command)}`);
+    }
+    console.log();
+    return;
+  }
+
+  if (plan) {
+    console.log();
+    if (plan.gpu_type)        console.log(`  ${chalk.bold('GPU:')}          ${plan.gpu_type}`);
+    if (plan.estimated_cost)  console.log(`  ${chalk.bold('Maximum cost:')} $${Number(plan.estimated_cost).toFixed(2)}`);
+    if (plan.max_runtime_min) console.log(`  ${chalk.bold('Max runtime:')}  ${plan.max_runtime_min} min`);
+    if (plan.requires_reduced_test)       console.log(`  ${chalk.yellow('!')} Multi-GPU detected — test uses a single GPU`);
+    if (plan.requires_funding_approval)   console.log(`  ${chalk.yellow('!')} Large download — funding required`);
+  }
+
+  await _approveAndRun(config, caseId, plan, chalk);
+}
+
+// Claim → approve → run for a case that already exists (just created via
+// /confirm above, or resumed via an existing_case input). Auth is required
+// from here on — diagnosis and case creation stay anonymous and free, but a
+// real GPU test needs a signed-in account. The CLI never grants a free-run
+// entitlement (web admin only, see grant_free_run in run_issue_routes.py);
+// it only redeems one a case already carries, same as normal billing.
+async function _approveAndRun(config, caseId, plan, chalk) {
+  const printResumeHint = () =>
+    console.error(chalk.dim(`  Resume this case: https://aibadgr.com/run-issue?case_id=${caseId}\n`));
+
+  let authConfig = config;
+  if (!authConfig.apiKey) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+      console.error(chalk.red('\n  ✗ Sign in required to approve a GPU test. Run: badgr login\n'));
+      printResumeHint();
+      process.exitCode = 1;
+      return;
+    }
+    console.log(chalk.yellow('\n  Sign in to continue. Opening browser...'));
+    try {
+      authConfig = await ensureLoggedIn(authConfig, chalk);
+    } catch (err) {
+      console.error(chalk.red(`\n  ✗ Sign-in failed: ${err.message}\n`));
+      printResumeHint();
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  try {
+    await callApi(`/run-issue/cases/${caseId}/claim`, {
+      method: 'POST', apiKey: authConfig.apiKey, baseUrl: authConfig.baseUrl, timeoutMs: 10_000,
+    });
+  } catch { /* already claimed — continue */ }
+
+  let approved;
+  try {
+    approved = await callApi(`/run-issue/cases/${caseId}/approve`, {
+      method:    'POST',
+      apiKey:    authConfig.apiKey,
+      baseUrl:   authConfig.baseUrl,
+      body: {
+        confirmed:               true,
+        funding_approved:        Boolean(plan?.requires_funding_approval),
+        reduced_test_confirmed:  Boolean(plan?.requires_reduced_test),
+      },
+      timeoutMs: 15_000,
+    });
+  } catch (err) {
+    if (err.httpStatus === 402 || err.message?.includes('402')) {
+      console.error(chalk.yellow('\n  ✗ Insufficient credits. Run: badgr billing\n'));
+    } else {
+      console.error(chalk.red(`\n  ✗ Approve failed: ${err.message}\n`));
+    }
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log(chalk.dim('\n  Launching capped smoke test...'));
+  let ran;
+  try {
+    ran = await callApi(`/run-issue/cases/${caseId}/run`, {
+      method: 'POST', apiKey: authConfig.apiKey, baseUrl: authConfig.baseUrl, timeoutMs: 30_000,
+    });
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ Launch failed: ${err.message}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log();
+  console.log(chalk.green('  Smoke test launched.'));
+  console.log(`  ${chalk.bold('Case:')}     ${caseId}`);
+  if (ran?.job_id)      console.log(`  ${chalk.bold('Job:')}      ${ran.job_id}`);
+  if (ran?.free_run_used) console.log(`  ${chalk.bold('Billing:')}  Free run — no charge`);
+  console.log(`  ${chalk.bold('Evidence:')} https://aibadgr.com/repro/${caseId}`);
+  console.log();
+}
+
+// Resume an existing case (bare case_id or a shared /repro or /run-issue
+// link) instead of diagnosing new input. No /confirm — the case already
+// exists; this only reads its current state and, with --approve, redeems
+// whatever entitlement/billing state it already carries.
+async function _diagnoseExistingCase(config, caseId, flags, chalk) {
+  let caseData;
+  try {
+    caseData = await callApi(`/run-issue/cases/${caseId}`, {
+      apiKey: config.apiKey || '', baseUrl: config.baseUrl, timeoutMs: 15_000,
+    });
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ Could not load case ${caseId}: ${err.message}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (flags.json) {
+    console.log(JSON.stringify(caseData, null, 2));
+    if (flags.approve) await _approveAndRun(config, caseId, caseData.test_plan, chalk);
+    return;
+  }
+
+  console.log();
+  console.log(`  ${chalk.bold('Case:')}      ${caseId}`);
+  console.log(`  ${chalk.bold('Status:')}    ${caseData.status}`);
+  if (caseData.workload_type) console.log(`  ${chalk.bold('Workload:')}  ${caseData.workload_type}`);
+  if (caseData.known_command) console.log(`  ${chalk.bold('Command:')}   ${caseData.known_command}`);
+  if ((caseData.missing_information || []).length) {
+    console.log();
+    console.log(`  ${chalk.bold('Missing information:')}`);
+    for (const m of caseData.missing_information) console.log(`    ? ${m}`);
+  }
+
+  console.log();
+  if (caseData.free_verification_consumed) {
+    console.log(`  ${chalk.dim('This case\'s free run has already been used — further verification is normal billing.')}`);
+  } else if (caseData.free_verification_available) {
+    console.log(`  ${chalk.green(`1 free verification job available — up to $${(caseData.free_verification_max_cost_usd ?? 5).toFixed(0)}`)}`);
+  } else if (caseData.test_plan) {
+    console.log(`  ${chalk.dim(`Verification available — max $${Number(caseData.test_plan.max_cost_usd ?? 0).toFixed(2)}`)}`);
+  }
+  console.log();
+
+  if (flags.approve) {
+    await _approveAndRun(config, caseId, caseData.test_plan, chalk);
+  } else {
+    console.log(`  ${chalk.bold('Resume:')} badgr diagnose ${caseId} --approve`);
+    console.log();
+  }
+}
+
+export async function diagnoseCommand(config, args, chalk) {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(DIAGNOSE_HELP);
+    return;
+  }
+
+  const flags = {};
+  let positional = null;
+  let i = 0;
+  while (i < args.length) {
+    const a = args[i];
+    if (a === '--docker')   { flags.docker  = args[++i]; i++; continue; }
+    if (a === '--repo')     { flags.repo    = args[++i]; i++; continue; }
+    if (a === '--comfyui')  { flags.comfyui = args[++i]; i++; continue; }
+    if (a === '--github')   { flags.github  = args[++i]; i++; continue; }
+    if (a === '--approve')  { flags.approve = true;  i++; continue; }
+    if (a === '--json')     { flags.json    = true;  i++; continue; }
+    if (!a.startsWith('-') && positional === null) positional = a;
+    i++;
+  }
+
+  if (!positional && !flags.docker && !flags.repo && !flags.comfyui) {
+    console.log(DIAGNOSE_HELP);
+    return;
+  }
+
+  let detected;
+  try {
+    detected = detectInput(positional, flags);
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ ${err.message}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!detected) {
+    console.log(DIAGNOSE_HELP);
+    return;
+  }
+
+  if (detected.kind === 'existing_case') {
+    await _diagnoseExistingCase(config, detected.caseId, flags, chalk);
+    return;
+  }
+
+  // --github opts into fetching a GitHub issue URL found inside pasted text
+  // (see the "Additional context found" notice) — never fetched by default.
+  if (flags.github) detected.body.github_url = flags.github;
+
+  if (!flags.json) {
+    console.log();
+    console.log(`  ${chalk.bold('Detected:')} ${detected.label}`);
+    console.log(chalk.dim('  Analysing...'));
+  }
+
+  let result;
+  try {
+    result = await callApi('/run-issue/extract', {
+      method:    'POST',
+      apiKey:    config.apiKey || '',
+      baseUrl:   config.baseUrl,
+      body:      detected.body,
+      timeoutMs: 120_000,
+    });
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ ${err.message}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (flags.json) {
+    console.log(JSON.stringify({ detected: detected.kind, ...result }, null, 2));
+    return;
+  }
+
+  console.log();
+  _printResult(result, chalk);
+
+  console.log();
+  console.log(chalk.dim('  Free diagnosis. No GPU was provisioned.'));
+  console.log(chalk.dim('  Full interactive flow: https://aibadgr.com/run-issue'));
+  console.log();
+
+  if (flags.approve) {
+    await _doApprove(config, result, chalk);
+  }
+}

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) {