badgr-cli 1.0.31 → 1.0.32

package/src/commands/test-run.js

@@ -0,0 +1,240 @@
+import { requireApiKey } from '../config.js';
+import { callApi, terminateDeployment } from '../api.js';
+import { addReceipt, generateReceiptId } from '../store.js';
+
+// max $0.80/hr × 2 min ≈ $0.027 total spend cap (smoke / Modal T4 tier)
+const TEST_MAX_PRICE  = 0.80;
+const TEST_MAX_RUNTIME_MS = 2 * 60 * 1000;
+const TEST_COMMAND    = ['python', '-c', "print('hello from badgr')"];
+// Use alpine (7MB) instead of slim (50MB) — dramatically faster image pull for smoke tests.
+// Falls back gracefully: alpine has python3 and supports the test command identically.
+const TEST_IMAGE      = 'python:3.11-alpine';
+const EXPECTED_OUTPUT = 'hello from badgr';
+
+// --provider flag resolves to a backend tier value.
+// 'tier1' → managed routing (default), 'tier2' → marketplace routing, 'secondary' → secondary dispatch.
+const PROVIDER_TO_TIER = { tier1: '1', tier2: '2', secondary: 'modal' };
+
+export function parseTestArgs(args) {
+  const flags = {};
+  let i = 0;
+  while (i < args.length) {
+    if (args[i] === '--provider' && args[i + 1]) { flags.provider = args[++i]; i++; continue; }
+    if (args[i] === '--no-tier-fallback') { flags.noTierFallback = true; i++; continue; }
+    i++;
+  }
+  return flags;
+}
+
+function step(chalk, ok, msg, detail = '') {
+  const icon = ok ? chalk.green('✓') : chalk.red('✗');
+  const suffix = detail ? chalk.dim(` — ${detail}`) : '';
+  console.log(`  ${icon} ${msg}${suffix}`);
+}
+
+async function pollStatus(config, depId, targetStatuses, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    await new Promise(r => setTimeout(r, 3000));
+    try {
+      const dep = await callApi(`/deployments/${depId}`, {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+      });
+      if (targetStatuses.has(dep.status)) return dep;
+    } catch { /* retry */ }
+  }
+  return null;
+}
+
+async function pollOutputOrDone(config, depId, expected, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    await new Promise(r => setTimeout(r, 3000));
+    try {
+      const dep = await callApi(`/deployments/${depId}`, {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+      });
+      if (dep.status === 'succeeded' || dep.status === 'failed') {
+        const data = await callApi(`/deployments/${depId}/logs`, {
+          apiKey: config.apiKey,
+          baseUrl: config.baseUrl,
+        });
+        const lines = data?.logs ?? [];
+        return {
+          done: true,
+          ok: dep.status === 'succeeded' && lines.some(l => l.includes(expected)),
+          exitCode: dep.exit_code,
+        };
+      }
+      const data = await callApi(`/deployments/${depId}/logs`, {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+      });
+      const lines = data?.logs ?? [];
+      if (lines.some(l => l.includes(expected))) return { done: true, ok: true, exitCode: 0 };
+    } catch { /* retry */ }
+  }
+  return { done: false, ok: false, exitCode: null };
+}
+
+export async function testCommand(config, args, chalk) {
+  requireApiKey(config);
+
+  const flags = parseTestArgs(Array.isArray(args) ? args : []);
+  const providerKey = flags.provider ? flags.provider.toLowerCase() : 'tier1';
+
+  if (providerKey === 'secondary') {
+    // Secondary dispatch provider uses a webhook model, not direct GPU rental.
+    // Verify the backend reports it as configured.
+    console.log(chalk.bold('\n⚡ Testing secondary dispatch provider\n'));
+    let routes;
+    try {
+      routes = await callApi('/compute/routes', { apiKey: config.apiKey, baseUrl: config.baseUrl });
+    } catch {
+      routes = null;
+    }
+    const secondaryRoute = Array.isArray(routes) ? routes.find(r => r.name === 'modal') : null;
+    if (secondaryRoute?.available) {
+      step(chalk, true, 'Secondary provider configured');
+      console.log(chalk.green('\n  ✓ Secondary dispatch provider is ready\n'));
+    } else {
+      step(chalk, false, 'Secondary provider configured', 'contact support to enable secondary dispatch');
+      console.log(chalk.red('\n  ✗ Secondary dispatch provider is not configured\n'));
+      process.exit(1);
+    }
+    return;
+  }
+
+  const tier = PROVIDER_TO_TIER[providerKey] ?? '1';
+  const tierLabel = tier === '1' ? 'tier 1 (managed routing)' : 'tier 2 (marketplace routing)';
+
+  console.log(chalk.bold('\n⚡ Running end-to-end test\n'));
+  console.log(chalk.dim(`  Command:  ${TEST_COMMAND.join(' ')}`));
+  console.log(chalk.dim(`  Routing:  ${tier === '1' ? 'tier 1 — managed provider routing' : 'tier 2 — marketplace routing'}`));
+  console.log(chalk.dim(`  Budget:   max $${TEST_MAX_PRICE.toFixed(2)}/hr · 2 minute cap (~$0.05 max)`));
+  console.log();
+
+  const rcptId = generateReceiptId();
+  let depId;
+
+  // ── 1. Provision ─────────────────────────────────────────────────────────
+  process.stdout.write(chalk.dim(`  Provisioning GPU (${tierLabel})...\n`));
+  let dep;
+  const baseBody = {
+    command: TEST_COMMAND,
+    image:   TEST_IMAGE,
+    gpu:     'auto',
+    max_price_per_hour: TEST_MAX_PRICE,
+  };
+  try {
+    dep = await callApi('/run', {
+      method: 'POST',
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+      body: { ...baseBody, tier },
+    });
+  } catch (err) {
+    if (err.errorData?.code === 'NO_CAPACITY_MATCH' && tier === '1' && !flags.noTierFallback) {
+      process.stdout.write('\n');
+      process.stdout.write(chalk.dim('  No tier 1 capacity — trying tier 2 marketplace routing...'));
+      try {
+        dep = await callApi('/run', {
+          method: 'POST',
+          apiKey: config.apiKey,
+          baseUrl: config.baseUrl,
+          body: { ...baseBody, tier: '2' },
+        });
+      } catch (err2) {
+        process.stdout.write('\n');
+        step(chalk, false, 'Provisioned', err2.message);
+        console.log();
+        console.error(chalk.red('  Test failed — no GPU capacity available on any provider.\n'));
+        process.exit(1);
+      }
+    } else if (err.errorData?.code === 'NO_CAPACITY_MATCH' && flags.noTierFallback) {
+      process.stdout.write('\n');
+      step(chalk, false, 'Provisioned', 'no tier 1 capacity');
+      console.log();
+      console.error(chalk.red('  Test failed — no tier 1 capacity (strict mode, no tier 2 fallback).\n'));
+      process.exit(1);
+    } else {
+      process.stdout.write('\n');
+      step(chalk, false, 'Provisioned', err.message);
+      console.log();
+      console.error(chalk.red('  Test failed — could not provision GPU.\n'));
+      process.exit(1);
+    }
+  }
+  depId = dep.deployment_id;
+  process.stdout.write('\n');
+  step(chalk, true, 'Provisioned', `${dep.deployment_id} on ${dep.gpu_type}`);
+
+  // ── 2. Container started ─────────────────────────────────────────────────
+  process.stdout.write(chalk.dim('  Waiting for container to start...'));
+  const started = await pollStatus(
+    config, depId,
+    // Modal serverless jobs may skip straight to succeeded when the callback fires.
+    new Set(['running', 'starting', 'succeeded', 'failed', 'stopped', 'completed']),
+    TEST_MAX_RUNTIME_MS,
+  );
+  process.stdout.write('\n');
+
+  if (!started || started.status === 'failed') {
+    step(chalk, false, 'Container started', started?.status ?? 'timeout');
+    console.log();
+    console.error(chalk.red('  Test failed — container did not start.\n'));
+    try { await terminateDeployment(config, depId); } catch { /* best-effort */ }
+    process.exit(1);
+  }
+  step(chalk, true, 'Container started');
+
+  // ── 3. Command output ────────────────────────────────────────────────────
+  process.stdout.write(chalk.dim('  Checking command output...'));
+  const outputResult = await pollOutputOrDone(config, depId, EXPECTED_OUTPUT, 90_000);
+  process.stdout.write('\n');
+  const gotOutput = outputResult.ok;
+  if (gotOutput) {
+    step(chalk, true, 'Command printed output');
+  } else if (outputResult.done && outputResult.exitCode !== 0) {
+    step(chalk, false, 'Command printed output', `exit ${outputResult.exitCode}`);
+  } else {
+    step(chalk, false, 'Command printed output', 'not found in logs (logs may be buffered)');
+  }
+
+  // ── 4. Stop billing ──────────────────────────────────────────────────────
+  process.stdout.write(chalk.dim('  Stopping deployment...'));
+  let stopped = false;
+  try {
+    await terminateDeployment(config, depId);
+    stopped = true;
+  } catch { /* best-effort */ }
+  process.stdout.write('\n');
+  step(chalk, stopped, 'Billing stopped');
+
+  // ── 5. Receipt ───────────────────────────────────────────────────────────
+  addReceipt({
+    receiptId:    rcptId,
+    action:       'badgr test',
+    deploymentId: depId,
+    gpu:          dep.gpu_type,
+    status:       gotOutput ? 'test_passed' : 'test_failed',
+    createdAt:    new Date().toISOString(),
+  });
+  step(chalk, true, 'Receipt created', rcptId);
+
+  // ── Summary ──────────────────────────────────────────────────────────────
+  console.log();
+  const passed = stopped && gotOutput;
+  if (passed) {
+    console.log(chalk.green(chalk.bold('  ✓ Test passed\n')));
+  } else {
+    if (!gotOutput) {
+      console.error(chalk.red('  Test failed — expected output not found in logs\n'));
+    } else {
+      console.error(chalk.red('  Test failed — could not stop billing\n'));
+    }
+    process.exit(1);
+  }
+}

package/src/commands/up.js

@@ -1,37 +1,31 @@
 import { parseSpec, validateSpec, specLines } from '../spec.js';
-import { getRoutePlan } from '../router.js';
 import { requireApiKey } from '../config.js';
 import { generateDeploymentId, generateReceiptId, addDeployment, addReceipt } from '../store.js';
-import { createDeployment } from '../api.js';
+import { createDeployment, callApi } from '../api.js';
 
-const OVERHEAD_PCT = 0.25;
+function printLivePlan(suggestions, gpu, chalk) {
+  const { matches = [], alternatives = [] } = suggestions;
 
-function printRoutePlan(plan, chalk) {
-  const { lane1, lane2, cheapestRate, costWithOverhead, canonical } = plan;
-
-  console.log(chalk.bold('  Lane 1 — Own GPU Hosts'));
+  console.log(chalk.bold('  Live availability'));
   console.log(`  ${'─'.repeat(40)}`);
-  console.log(chalk.dim(`  ${lane1.description}`));
+  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')}`);
+    console.log(chalk.dim(`  ${matches.length} offer(s) found`));
+  }
   console.log();
 
-  console.log(chalk.bold('  Lane 2 — Overflow Providers  (cheapest-first)'));
-  console.log(`  ${'─'.repeat(40)}`);
-  if (lane2.length === 0) {
-    console.log(chalk.yellow(`  No pricing data for ${canonical}`));
-  } else {
-    lane2.forEach((p, i) => {
-      const arrow = i === 0 ? chalk.green(' ← primary') : '';
-      console.log(
-        `  ${String(i + 1)}. ${p.provider.padEnd(12)} ${canonical.padEnd(10)}` +
-        `  $${p.ratePerHour.toFixed(2)}/hr` +
-        `  reliability: ${Math.round(p.reliability * 100)}%${arrow}`
-      );
+  if (alternatives.length > 0) {
+    console.log(chalk.bold('  Alternatives if unavailable'));
+    console.log(`  ${'─'.repeat(40)}`);
+    alternatives.slice(0, 3).forEach((a, i) => {
+      const diff = a.diff_desc ? chalk.dim(` — ${a.diff_desc}`) : '';
+      console.log(`  ${i + 1}. ${chalk.cyan(a.gpu)} in ${a.region}  $${a.price.toFixed(2)}/hr${diff}`);
     });
     console.log();
-    console.log(`  Estimated range: $${cheapestRate.toFixed(2)}–$${lane2[lane2.length - 1].ratePerHour.toFixed(2)}/hr`);
-    console.log(chalk.dim(`  Estimated Badgr price: ~$${costWithOverhead.toFixed(2)}/hr`));
   }
-  console.log();
   console.log(chalk.dim('  Remove --dry-run to provision.'));
   console.log();
 }
@@ -45,15 +39,27 @@ export async function upCommand(config, args, chalk) {
     return;
   }
 
-  // ── Dry-run: show route plan and exit ─────────────────────────────────────
+  // ── Dry-run: show live route plan from backend ───────────────────────────
   if (spec.dryRun) {
     console.log(chalk.bold('\n🔍 Dry Run — Route Plan\n'));
     console.log(chalk.bold('  Spec'));
     console.log(`  ${'─'.repeat(40)}`);
     specLines(spec).forEach(l => console.log(`  ${l}`));
     console.log();
-    const plan = getRoutePlan(spec.gpu, spec.count);
-    printRoutePlan(plan, chalk);
+
+    requireApiKey(config);
+    try {
+      const params = new URLSearchParams({ gpu: spec.gpu, max_price: String(spec.maxPrice ?? 10) });
+      if (spec.region) params.set('region', spec.region);
+      const suggestions = await callApi(`/capacity/suggestions?${params}`, {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+      });
+      printLivePlan(suggestions, spec.gpu, chalk);
+    } catch (err) {
+      console.log(chalk.yellow(`  Could not fetch live availability: ${err.message}`));
+      console.log(chalk.dim('  Tip: check `badgr capacity` for live data.\n'));
+    }
     return;
   }
 

package/src/config.js

@@ -6,16 +6,61 @@ export const CONFIG_DIR = join(homedir(), '.badgr');
 export const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
 
 export const DEFAULTS = {
-  baseUrl: 'https://api.badgr.ai/v1',
+  baseUrl: 'https://aibadgr.com/v1',
   defaultModel: 'meta-llama/Llama-3.1-8B-Instruct',
 };
 
+/** URLs that do not resolve or are superseded by aibadgr.com/v1 (nginx) */
+const LEGACY_BASE_URLS = new Set([
+  'https://api.badgr.ai/v1',
+  'https://api.badgr.ai',
+  'http://api.badgr.ai/v1',
+  'http://api.badgr.ai',
+  'https://api.aibadgr.com/v1',
+  'https://api.aibadgr.com',
+  'http://api.aibadgr.com/v1',
+  'http://api.aibadgr.com',
+]);
+
+export function normalizeBaseUrl(url) {
+  if (!url?.trim()) return DEFAULTS.baseUrl;
+  const trimmed = url.trim().replace(/\/+$/, '');
+  if (LEGACY_BASE_URLS.has(trimmed)) return DEFAULTS.baseUrl;
+  return trimmed.endsWith('/v1') ? trimmed : `${trimmed}/v1`;
+}
+
+function applyEnvOverrides(config) {
+  const envBase = process.env.BADGR_API_URL?.trim();
+  if (envBase) config.baseUrl = normalizeBaseUrl(envBase);
+  const envKey = process.env.BADGR_API_KEY?.trim();
+  if (envKey) config.apiKey = envKey;
+  return config;
+}
+
 export function loadConfig(configFile = CONFIG_FILE) {
-  if (!existsSync(configFile)) return { ...DEFAULTS };
+  if (!existsSync(configFile)) {
+    return applyEnvOverrides({ ...DEFAULTS });
+  }
   try {
-    return { ...DEFAULTS, ...JSON.parse(readFileSync(configFile, 'utf8')) };
+    const parsed = JSON.parse(readFileSync(configFile, 'utf8'));
+    const previousBase = parsed.baseUrl;
+    const config = applyEnvOverrides({
+      ...DEFAULTS,
+      ...parsed,
+      baseUrl: normalizeBaseUrl(parsed.baseUrl ?? DEFAULTS.baseUrl),
+    });
+    if (
+      configFile === CONFIG_FILE &&
+      previousBase &&
+      normalizeBaseUrl(previousBase) !== previousBase
+    ) {
+      const merged = { ...parsed, baseUrl: config.baseUrl };
+      mkdirSync(dirname(configFile), { recursive: true });
+      writeFileSync(configFile, JSON.stringify(merged, null, 2));
+    }
+    return config;
   } catch {
-    return { ...DEFAULTS };
+    return applyEnvOverrides({ ...DEFAULTS });
   }
 }
 

package/src/fallback.js

@@ -0,0 +1,179 @@
+import readline from 'readline';
+
+// ── Shared routing helpers ────────────────────────────────────────────────────
+
+/** Rates above this threshold trigger a visible warning when no --max-cost is set. */
+export const HIGH_RATE_THRESHOLD = 3.00;
+
+/** Normalise --tier flag variants to '1' or '2'. */
+export function normalizeTier(tier) {
+  return (tier === '2' || tier === 'tier2' || tier === 'tier-2') ? '2' : (tier || '1');
+}
+
+/**
+ * Sentinel error thrown when callWithFallback cannot provision capacity.
+ * The message is already formatted for display; callers should print it and exit.
+ */
+export class CapacityError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'CapacityError';
+    this.isCapacityError = true;
+  }
+}
+
+/**
+ * Call an API endpoint with automatic tier-2 expansion on NO_CAPACITY_MATCH.
+ * Returns the deployment object on success.
+ * Throws CapacityError (pre-formatted for display) on unrecoverable failure.
+ * Re-throws payment errors (err.isPaymentRequired) for callers to handle.
+ *
+ * @param {string}   endpoint          - '/run' or '/serve'
+ * @param {object}   callOpts          - { apiKey, baseUrl }
+ * @param {function} buildBody         - (tierOverride?) => body object
+ * @param {string}   effectiveTier
+ * @param {object}   chalk
+ * @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
+ */
+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
+
+  async function attempt(body) {
+    return callApi(endpoint, { method: 'POST', ...callOpts, body, timeoutMs: 30_000 });
+  }
+
+  function buildCapacityError(err, isFallback) {
+    const d = err.errorData;
+    let msg;
+    if (d?.code === 'NO_CAPACITY_MATCH') {
+      msg = chalk.red('\n  ✗ No suitable GPU capacity available right now.\n') +
+            chalk.dim('  Try `badgr capacity` to see what\'s available, or try again shortly.');
+    } else if (d?.code === 'PROVISIONING_FAILED' || d?.code === 'PROVIDER_ADAPTER_ERROR') {
+      if (d?.low_cost_provider_failed) {
+        msg = chalk.red(`\n  ✗ No suitable capacity available right now. Try again shortly.\n`);
+      } else {
+        msg = chalk.red(`\n  ✗ Capacity found but ${thing} failed to start. Please try again.\n`);
+        if (process.env.BADGR_DEBUG === '1' || process.env.BADGR_DEBUG === 'true') {
+          if (d?.debug_error) msg += chalk.dim(`  Detail: ${d.debug_error}`);
+        } else {
+          msg += chalk.dim(`  Run BADGR_DEBUG=1 ${cmd} … for a full trace.\n`);
+        }
+      }
+    } else {
+      msg = chalk.red(`\n  ✗ Could not start ${thing}: ${err.message}\n`) +
+            chalk.dim(`  Run BADGR_DEBUG=1 ${cmd} … for a full trace.`);
+      if (!isFallback) msg += '\n' + chalk.dim(`  Check config: badgr config\n`);
+    }
+    return new CapacityError(msg);
+  }
+
+  try {
+    return await attempt(buildBody());
+  } catch (err) {
+    const d = err.errorData;
+
+    if (d?.code === 'NO_CAPACITY_MATCH' && effectiveTier !== '2' && allowTier2Fallback) {
+      console.log(chalk.dim('\n  Primary capacity unavailable — expanding search...\n'));
+      try {
+        return await attempt(buildBody('2'));
+      } catch (err2) {
+        throw buildCapacityError(err2, true);
+      }
+    }
+
+    if (err.isPaymentRequired) throw err; // let caller handle payment errors
+    throw buildCapacityError(err, false);
+  }
+}
+
+// ── GPU fallback prompt ───────────────────────────────────────────────────────
+
+// GPU descriptions for display only — no scoring logic lives here.
+const GPU_DISPLAY = {
+  RTX_3080: { desc: 'Dev, light inference' },
+  RTX_3090: { desc: 'Dev, inference' },
+  RTX_4080: { desc: 'Inference and dev workloads' },
+  RTX_4090: { desc: 'Inference, training, dev' },
+  L40S:     { desc: 'Inference, vLLM, batch jobs' },
+  A6000:    { desc: 'Training, large models, inference' },
+  A100:     { desc: 'Large-scale training and inference' },
+  H100:     { desc: 'Large model training, best throughput' },
+};
+
+/**
+ * Sort alternatives for display.
+ */
+export function rankAlternatives(requestedGpu, alternatives, mode = 'closest') {
+  if (!alternatives || alternatives.length === 0) return [];
+  if (mode === 'cheapest') return [...alternatives].sort((a, b) => a.price - b.price);
+  if (alternatives.some(a => a.rank != null)) {
+    return [...alternatives].sort((a, b) => (a.rank ?? 999) - (b.rank ?? 999));
+  }
+  return [...alternatives].sort((a, b) => a.price - b.price);
+}
+
+/**
+ * One-line diff for display.
+ */
+export function diffDescription(requestedGpu, altGpu, alt = {}) {
+  return alt.diff_desc || '';
+}
+
+function ask(prompt) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => rl.question(prompt, ans => { rl.close(); resolve(ans.trim()); }));
+}
+
+/**
+ * Show the interactive fallback prompt and return the chosen alternative or null.
+ * Non-TTY environments auto-select the top-ranked option.
+ */
+export async function promptFallback(requestedGpu, ranked, chalk) {
+  if (ranked.length === 0) return null;
+
+  const top    = ranked[0];
+  const others = ranked.slice(1, 4);
+  const topDisp = GPU_DISPLAY[top.gpu];
+
+  console.log(chalk.yellow(`\n  ${requestedGpu} isn't available right now.\n`));
+  console.log(chalk.bold('  Closest match:'));
+  console.log(`    ${chalk.cyan(top.gpu)} in ${top.region}`);
+  console.log(`    ${chalk.green('$' + top.price.toFixed(2) + '/hr')} estimated price`);
+  if (top.diff_desc) console.log(`    ${chalk.dim(top.diff_desc)}`);
+  else if (topDisp?.desc) console.log(`    ${topDisp.desc}`);
+  console.log(chalk.dim('    (availability estimated from market data — not pre-verified)'));
+  console.log();
+
+  if (!process.stdin.isTTY) {
+    console.log(chalk.dim(`  Auto-selecting ${top.gpu} (non-interactive).`));
+    return top;
+  }
+
+  console.log(`  Press ${chalk.bold('Enter')} to run on ${chalk.cyan(top.gpu)}`);
+  if (others.length > 0) {
+    console.log('  or type:');
+    for (const [i, alt] of others.entries()) {
+      const disp = GPU_DISPLAY[alt.gpu];
+      const hint = disp ? disp.desc.split(',')[0].toLowerCase() : '';
+      console.log(`    ${chalk.bold(String(i + 1))} = ${alt.gpu}${hint ? ', ' + hint : ''}`);
+    }
+  }
+  console.log(`    ${chalk.bold('q')} = cancel`);
+  console.log();
+
+  const answer = await ask('  > ');
+
+  if (answer === '') return top;
+  if (answer.toLowerCase() === 'q') return null;
+
+  const idx = parseInt(answer, 10);
+  if (!isNaN(idx) && idx >= 1 && idx <= others.length) return others[idx - 1];
+
+  console.log(chalk.dim(`  Unrecognised input — using ${top.gpu}.`));
+  return top;
+}