badgr-cli 1.0.30 → 1.0.31

package/src/commands/capacity.js

@@ -1,111 +0,0 @@
-import { requireApiKey } from '../config.js';
-import { callApi } from '../api.js';
-
-/**
- * badgr capacity              # show what's available right now (auto)
- * badgr capacity --gpu A100   # check a specific GPU type
- */
-function parseCapacityArgs(args) {
-  const flags = {};
-  let i = 0;
-  while (i < args.length) {
-    if (args[i] === '--gpu')       { flags.gpu = args[++i]; i++; continue; }
-    if (args[i] === '--region')    { flags.region = args[++i]; i++; continue; }
-    if (args[i] === '--max-price') { flags.maxPrice = parseFloat(args[++i]); i++; continue; }
-    i++;
-  }
-  return flags;
-}
-
-export async function capacityCommand(config, args, chalk) {
-  const flags = parseCapacityArgs(args);
-  requireApiKey(config);
-
-  const maxPrice = flags.maxPrice ?? 10;
-
-  // No --gpu: show cheapest runnable GPU across all types
-  if (!flags.gpu) {
-    console.log(chalk.bold('\nAvailable GPU capacity\n'));
-    process.stdout.write(chalk.dim('  Checking availability...\n'));
-
-    let data;
-    try {
-      const params = new URLSearchParams({ max_price: String(maxPrice) });
-      if (flags.region) params.set('region', flags.region.toUpperCase());
-      data = await callApi(`/capacity/auto?${params}`, {
-        apiKey: config.apiKey,
-        baseUrl: config.baseUrl,
-      });
-    } catch (err) {
-      if (err.errorData?.code === 'NO_CAPACITY_MATCH') {
-        console.log(chalk.dim('\n  No GPU capacity available right now.\n'));
-        console.log(chalk.dim('  Try again in a few minutes, or check a specific GPU with --gpu <type>.\n'));
-        return;
-      }
-      console.error(chalk.red(`\n  ✗ Capacity check failed: ${err.message}\n`));
-      process.exit(1);
-    }
-
-    console.log();
-    console.log(`  ${chalk.bold('Cheapest available:')} ${chalk.cyan(data.gpu)} in ${data.region}   ${chalk.green('$' + data.price.toFixed(2) + '/hr')}`);
-    console.log();
-    console.log(`  ${chalk.bold('Run now:')}`);
-    console.log(chalk.cyan(`    badgr run python train.py`));
-    console.log(chalk.cyan(`    badgr serve meta-llama/Llama-3.1-8B-Instruct`));
-    console.log();
-    console.log(chalk.dim(`  Use badgr capacity --gpu A100 to check a specific GPU type.`));
-    console.log();
-    return;
-  }
-
-  // --gpu specified: show availability for that type
-  const gpu = flags.gpu.toUpperCase().replace('-', '_');
-  const params = new URLSearchParams({ gpu, max_price: String(maxPrice) });
-  if (flags.region) params.set('region', flags.region.toUpperCase());
-
-  console.log(chalk.bold(`\nCapacity: ${gpu}\n`));
-  process.stdout.write(chalk.dim('  Checking...\n'));
-
-  let data;
-  try {
-    data = await callApi(`/capacity/suggestions?${params}`, {
-      apiKey: config.apiKey,
-      baseUrl: config.baseUrl,
-    });
-  } catch (err) {
-    console.error(chalk.red(`\n  ✗ Capacity check failed: ${err.message}\n`));
-    process.exit(1);
-  }
-
-  const matches = data.matches ?? [];
-  if (matches.length > 0) {
-    console.log(chalk.bold('\n  Available now:\n'));
-    for (const m of matches) {
-      console.log(`    ${chalk.green('●')} ${m.gpu} in ${m.region}   ${chalk.green('$' + m.price.toFixed(2) + '/hr')}`);
-    }
-    console.log();
-    const regionFlag = flags.region ? ` --region ${flags.region.toUpperCase()}` : '';
-    console.log(`  ${chalk.bold('Run:')}`);
-    console.log(chalk.cyan(`    badgr run python train.py --gpu ${gpu}${regionFlag}`));
-    console.log();
-  } else {
-    const regionLabel = flags.region ? ` in ${flags.region.toUpperCase()}` : '';
-    console.log(chalk.dim(`\n  No ${gpu} available right now under $${maxPrice.toFixed(2)}/hr${regionLabel}.\n`));
-
-    const alternatives = data.alternatives ?? [];
-    if (alternatives.length > 0) {
-      console.log(chalk.bold('  Available alternatives:\n'));
-      for (const a of alternatives) {
-        console.log(`    ${chalk.dim('●')} ${a.gpu} in ${a.region}   $${a.price.toFixed(2)}/hr`);
-      }
-      console.log();
-      console.log(`  ${chalk.bold('Try:')}`);
-      for (const a of alternatives.slice(0, 3)) {
-        console.log(chalk.cyan(`    badgr run python train.py --gpu ${a.gpu}`));
-      }
-      console.log();
-    } else {
-      console.log(chalk.dim('  No alternatives found. Try `badgr capacity` to see global availability.\n'));
-    }
-  }
-}

package/src/commands/test-run.js

@@ -1,240 +0,0 @@
-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/fallback.js

@@ -1,170 +0,0 @@
-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');
-}
-
-/**
- * Call an API endpoint with automatic tier-2 expansion on NO_CAPACITY_MATCH.
- * Returns the deployment object on success; throws or calls process.exit on failure.
- *
- * @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' }
- */
-export async function callWithFallback(endpoint, callOpts, buildBody, effectiveTier, chalk, labels) {
-  const { callApi } = await import('./api.js');
-  const thing = labels?.thing ?? 'job';
-  const cmd   = labels?.cmd   ?? 'badgr run';
-
-  async function attempt(body) {
-    return callApi(endpoint, { method: 'POST', ...callOpts, body });
-  }
-
-  function handleErr(err, isFallback) {
-    const d = err.errorData;
-    if (d?.code === 'NO_CAPACITY_MATCH') {
-      console.error(chalk.red('\n  ✗ No suitable GPU capacity available right now.\n'));
-      console.error(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) {
-        console.error(chalk.red(`\n  ✗ No suitable capacity available right now. Try again shortly.\n`));
-      } else {
-        console.error(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) console.error(chalk.dim(`  Detail: ${d.debug_error}`));
-        } else {
-          console.error(chalk.dim(`  Run BADGR_DEBUG=1 ${cmd} … for a full trace.\n`));
-        }
-      }
-    } else {
-      console.error(chalk.red(`\n  ✗ Could not start ${thing}: ${err.message}\n`));
-      console.error(chalk.dim(`  Run BADGR_DEBUG=1 ${cmd} … for a full trace.`));
-      if (!isFallback) console.error(chalk.dim(`  Check config: badgr config\n`));
-    }
-    process.exit(1);
-  }
-
-  try {
-    return await attempt(buildBody());
-  } catch (err) {
-    const d = err.errorData;
-
-    if (d?.code === 'NO_CAPACITY_MATCH' && effectiveTier !== '2') {
-      console.log(chalk.dim('\n  Primary capacity unavailable — expanding search...\n'));
-      try {
-        return await attempt(buildBody('2'));
-      } catch (err2) {
-        handleErr(err2, true);
-      }
-    }
-
-    if (err.isPaymentRequired) throw err; // let caller handle payment errors
-    handleErr(err, false);
-  }
-}
-
-// ── GPU fallback prompt ───────────────────────────────────────────────────────
-
-// GPU descriptions for display only — no scoring logic lives here.
-// Ranking is computed server-side and returned as `rank` on each alternative.
-const GPU_DISPLAY = {
-  RTX_3080: { desc: 'Dev, light 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.
- *
- * - mode 'closest'  → use backend `rank` field (1 = best match); fall back to price.
- * - mode 'cheapest' → sort by price ascending only.
- *
- * The scoring algorithm has been removed from the CLI; the backend now
- * computes and attaches `rank` and `diff_desc` to every alternative.
- */
-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);
-  // 'closest': honour backend rank when present
-  if (alternatives.some(a => a.rank != null)) {
-    return [...alternatives].sort((a, b) => (a.rank ?? 999) - (b.rank ?? 999));
-  }
-  // Older backend without rank — fall back to price
-  return [...alternatives].sort((a, b) => a.price - b.price);
-}
-
-/**
- * One-line diff for display. Uses `diff_desc` from backend when present,
- * otherwise omits the diff rather than duplicating the scoring logic.
- */
-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;
-}