badgr-cli 1.0.25 → 1.0.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "badgr-cli",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "description": "Badgr, run or serve GPU workloads from one command",
   "type": "module",
   "bin": {

package/src/commands/run.js

@@ -81,18 +81,36 @@ function renderStatusBar(chalk, { elapsedMs, ratePerHour, gpuUtil, cpuUtil, maxR
   return chalk.dim('  ' + parts.join('  •  '));
 }
 
-// Wait for status to leave 'starting' (smoke check running on backend).
+// Wait for status to leave 'starting'/'queued'/'provisioning'.
+// This covers image pull time — runtime limit does NOT start until this returns.
 // Returns the final dep object with status 'running' or 'failed'.
 async function waitForRunning(config, depId, chalk) {
-  const POLL_MS = 3000;
-  const TIMEOUT_MS = 120_000; // 2 min max for smoke check
-  const startMs = Date.now();
-  let dots = 0;
+  const POLL_MS     = 3000;
+  const TIMEOUT_MS  = 5 * 60 * 1000; // 5 min startup grace (image pull + container init)
+  const startMs     = Date.now();
+  const PHASES = [
+    { afterMs:     0, label: '  Starting machine'     },
+    { afterMs: 15000, label: '  Pulling image'         },
+    { afterMs: 60000, label: '  Starting container'    },
+    { afterMs: 180000, label: '  Running command'      },
+  ];
+
+  let lastPhaseIdx = -1;
+  const STARTUP_STATES = new Set(['queued', 'provisioning', 'starting']);
 
-  process.stdout.write(chalk.dim('  Waiting for container to start'));
   const ticker = setInterval(() => {
+    const elapsed = Date.now() - startMs;
+    // Find the latest phase whose afterMs has been passed
+    let phaseIdx = 0;
+    for (let i = 0; i < PHASES.length; i++) {
+      if (elapsed >= PHASES[i].afterMs) phaseIdx = i;
+    }
+    if (phaseIdx !== lastPhaseIdx) {
+      process.stdout.write('\r\x1b[2K');
+      process.stdout.write(chalk.dim(PHASES[phaseIdx].label));
+      lastPhaseIdx = phaseIdx;
+    }
     process.stdout.write('.');
-    dots++;
   }, 1000);
 
   try {
@@ -102,23 +120,22 @@ async function waitForRunning(config, depId, chalk) {
         apiKey: config.apiKey,
         baseUrl: config.baseUrl,
       });
-      if (dep.status !== 'starting') {
-        clearInterval(ticker);
+      if (!STARTUP_STATES.has(dep.status)) {
         process.stdout.write('\n');
         return dep;
       }
     }
   } finally {
     clearInterval(ticker);
-    if (dots > 0) process.stdout.write('\n');
+    process.stdout.write('\n');
   }
 
-  // Timed out waiting — return whatever we have
+  // Timed out — return last known state
   return await callApi(`/deployments/${depId}`, { apiKey: config.apiKey, baseUrl: config.baseUrl });
 }
 
 async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost = null, ratePerHour = 0, onTeardown }) {
-  const TERMINAL = new Set(['stopped', 'failed', 'completed']);
+  const TERMINAL = new Set(['stopped', 'failed', 'completed', 'succeeded']);
   const POLL_MS  = 4000;
   let seenContent     = new Set();  // track by content, not index, to avoid reprinting stale lines
   let lastStatus      = '';
@@ -342,7 +359,11 @@ export async function runCommand(config, args, chalk) {
   requireApiKey(config);
 
   const command      = positional.length > 0 ? positional : undefined;
-  const image        = flags.image || (command ? 'python:3.11-slim' : undefined);
+  // Use alpine for smoke tests (7MB vs 50MB — much faster pull), slim for general workloads
+  const inferredImage = (command && inferWorkload(command) === 'smoke_test')
+    ? 'python:3.11-alpine'
+    : 'python:3.11-slim';
+  const image = flags.image || (command ? inferredImage : undefined);
   const detach       = flags.detach || false;
   const fallbackMode = flags.noFallback ? 'none' : (flags.fallback || 'closest');
   const maxRuntimeMs = flags.maxRuntime ? flags.maxRuntime * 60 * 1000 : null;
@@ -354,54 +375,18 @@ export async function runCommand(config, args, chalk) {
     : (flags.tier || '1');
 
   // ── Auto GPU selection (no --gpu specified) ────────────────────────────────
-  let gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : null;
-  let autoRegion = null;
+  let gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : 'auto';
 
   // Infer workload from the command so the backend can apply the correct VRAM floor.
   const workload = command ? inferWorkload(command) : 'general';
   const workloadLabel = WORKLOAD_LABELS[workload] || 'GPU job';
 
-  if (!gpu) {
+  if (gpu === 'auto') {
     console.log(chalk.bold(`\n⚡ Running ${workloadLabel}\n`));
     if (command) console.log(`  ${chalk.bold('Command:')}  ${command.join(' ')}`);
     if (image)   console.log(`  ${chalk.bold('Image:')}    ${image}`);
     if (effectiveTier === '2') console.log(`  ${chalk.dim('(tier 2 — marketplace routing)')}`)
     console.log();
-    process.stdout.write(chalk.dim('  Finding best GPU...'));
-
-    let best;
-    try {
-      best = await findAutoGpu(config, chalk, effectiveTier, workload);
-    } catch (err) {
-      process.stdout.write('\n');
-      console.error(chalk.red(`\n  ✗ Could not find GPU capacity: ${err.message}\n`));
-      process.exit(1);
-    }
-
-    process.stdout.write('\n');
-
-    if (!best) {
-      console.error(chalk.red('\n  ✗ No GPU capacity available right now.\n'));
-      console.error(chalk.dim('  Run `badgr capacity` for details, or try again in a few minutes.'));
-      process.exit(1);
-    }
-
-    const vramNote = best.min_vram_gb ? chalk.dim(` (${best.min_vram_gb}GB VRAM)`) : '';
-    console.log(`\n  ${chalk.bold('Selected:')}   ${chalk.cyan(best.gpu)} in ${best.region} — ${chalk.green('$' + best.price.toFixed(2) + '/hr')}${vramNote}`);
-    console.log();
-
-    if (effectiveTier === '2' && process.stdin.isTTY) {
-      // Budget mode: confirm because the user is being routed to a less reliable provider.
-      const answer = await askConfirm(`  Press ${chalk.bold('Enter')} to run on tier 2 (marketplace), or ${chalk.bold('q')} to cancel: `);
-      if (answer.toLowerCase() === 'q') {
-        console.log(chalk.dim('\n  Cancelled.\n'));
-        process.exit(0);
-      }
-    }
-
-    gpu = best.gpu;
-    autoRegion = best.region;
-    console.log();
   } else {
     // Specific GPU requested — show header
     console.log(chalk.bold('\n⚡ Running GPU job\n'));
@@ -419,15 +404,13 @@ export async function runCommand(config, args, chalk) {
     }
   }
 
-  console.log(chalk.dim('  Finding best available GPU capacity...'));
+  console.log(chalk.dim('  Starting machine...'));
   if (process.env.BADGR_DEBUG === '1' || process.env.BADGR_DEBUG === 'true') {
     console.log(chalk.dim(`  API: ${config.baseUrl}`));
   }
 
-  function buildBody(gpuOverride, regionOverride) {
-    const effectiveRegion = regionOverride
-      ?? autoRegion
-      ?? (flags.region ? flags.region.toUpperCase() : undefined);
+  function buildBody(gpuOverride) {
+    const effectiveRegion = flags.region ? flags.region.toUpperCase() : undefined;
     return {
       command,
       image,
@@ -544,8 +527,10 @@ export async function runCommand(config, args, chalk) {
     return;
   }
 
-  // If the backend is still running the smoke check, wait for it to finish.
-  if (dep.status === 'starting') {
+  // Wait through startup phases (queued → provisioning → starting → running).
+  // The max-runtime clock does NOT start until this returns — image pull time is free.
+  const STARTUP_STATES = new Set(['queued', 'provisioning', 'starting']);
+  if (STARTUP_STATES.has(dep.status)) {
     console.log();
     dep = await waitForRunning(config, dep.deployment_id, chalk);
   }
@@ -559,7 +544,7 @@ export async function runCommand(config, args, chalk) {
   }
 
   const ratePerHour = dep.cost_per_hour || 0;
-  console.log(chalk.dim('\n  ── Live status (Ctrl+C to stop) ─────────────────────────────────\n'));
+  console.log(chalk.dim('\n  ── Running command (Ctrl+C to stop) ────────────────────────────\n'));
 
   async function teardown(reason) {
     const labels = {
@@ -621,7 +606,7 @@ export async function runCommand(config, args, chalk) {
     }
     console.log();
     process.exit(exitCode ?? 1);
-  } else if (finalStatus === 'completed' && (exitCode === 0 || exitCode === null)) {
-    console.log(chalk.green(`\n  ✓ Complete\n`));
+  } else if ((finalStatus === 'completed' || finalStatus === 'succeeded') && (exitCode === 0 || exitCode === null)) {
+    console.log(chalk.green(`\n  ✓ Job complete\n`));
   }
 }

package/src/commands/test-run.js

@@ -6,7 +6,9 @@ import { addReceipt, generateReceiptId } from '../store.js';
 const TEST_MAX_PRICE  = 1.50;
 const TEST_MAX_RUNTIME_MS = 2 * 60 * 1000;
 const TEST_COMMAND    = ['python', '-c', "print('hello from badgr')"];
-const TEST_IMAGE      = 'python:3.11-slim';
+// 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.
@@ -106,7 +108,7 @@ export async function testCommand(config, args, chalk) {
   const baseBody = {
     command: TEST_COMMAND,
     image:   TEST_IMAGE,
-    gpu:     'RTX_3080',
+    gpu:     'auto',
     max_price_per_hour: TEST_MAX_PRICE,
   };
   try {
@@ -190,18 +192,22 @@ export async function testCommand(config, args, chalk) {
     action:       'badgr test',
     deploymentId: depId,
     gpu:          dep.gpu_type,
-    status:       'test_complete',
+    status:       gotOutput ? 'test_passed' : 'test_failed',
     createdAt:    new Date().toISOString(),
   });
   step(chalk, true, 'Receipt created', rcptId);
 
   // ── Summary ──────────────────────────────────────────────────────────────
   console.log();
-  const passed = stopped;
+  const passed = stopped && gotOutput;
   if (passed) {
     console.log(chalk.green(chalk.bold('  ✓ Test passed\n')));
   } else {
-    console.log(chalk.red(chalk.bold('  ✗ Test failed\n')));
+    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);
   }
 }