badgr-cli 1.0.44 → 1.0.46

package/src/badgr.js

@@ -20,17 +20,24 @@ import { embedCommand }      from './commands/embed.js';
 import { templateCommand }   from './commands/template.js';
 import { workloadCommand }   from './commands/workload.js';
 import { workspaceCommand }  from './commands/workspace.js';
+import { detectCommand }     from './commands/detect.js';
+import { restartCommand }    from './commands/restart.js';
+import { heartbeatCommand }  from './commands/heartbeat.js';
 
 const HELP = `
 ${chalk.bold('badgr')} — run or serve GPU workloads from one command
 
 ${chalk.bold('COMMANDS')}
   ${chalk.cyan('badgr login')}               Authenticate with your API key
+  ${chalk.cyan('badgr detect <path>')}       Inspect a project and report the GPU job Badgr would run
   ${chalk.cyan('badgr run <command>')}       Run a one-off GPU job
   ${chalk.cyan('badgr serve <model>')}       Serve a model with an OpenAI-compatible endpoint
+  ${chalk.cyan('badgr serve openwebui')}     Serve Open WebUI — chat UI, connects to a model endpoint
   ${chalk.cyan('badgr status')}              Show what's running and what's billing
   ${chalk.cyan('badgr logs <id>')}           Stream logs for a running job or endpoint
   ${chalk.cyan('badgr down <id>')}           Stop a deployment and end billing
+  ${chalk.cyan('badgr restart <id>')}        Relaunch an endpoint with the same config and API key
+  ${chalk.cyan('badgr heartbeat <id>')}      Reset an endpoint's idle-timeout clock
   ${chalk.cyan('badgr receipts')}            Show cost history
   ${chalk.cyan('badgr test')}               Run an end-to-end test (provision → run → teardown)
   ${chalk.cyan('badgr capacity')}            Check what GPU capacity is available right now
@@ -53,12 +60,20 @@ ${chalk.bold('SHORTCUTS')}  ${chalk.dim('(wrappers around run / serve for common
   ${chalk.cyan('badgr serve --list-aliases')}          List blessed vLLM model shortcuts (qwen-7b, llama-8b, …)
 
 ${chalk.bold('EXAMPLES')}
+  ${chalk.dim('# Point Badgr at any project and see what it detects:')}
+  badgr detect .
+  badgr run . --max-cost 5 --save my-job
+  badgr workload run my-job
+
   ${chalk.dim('# Verify the stack works end-to-end:')}
   badgr test
 
   ${chalk.dim('# Serve a model (OpenAI-compatible):')}
   badgr serve meta-llama/Llama-3.1-8B-Instruct --max-cost 10
 
+  ${chalk.dim('# Serve Open WebUI, connected to a model endpoint:')}
+  badgr serve openwebui --model qwen-7b --max-cost 10
+
   ${chalk.dim('# Serve a Hugging Face GGUF file via llama.cpp:')}
   badgr serve --runtime llama.cpp \\
     --hf-repo org/model-repo \\
@@ -141,11 +156,14 @@ async function main() {
 
   switch (cmd) {
     case 'login':    return loginCommand(chalk, saveConfig);
+    case 'detect':   return detectCommand(config, rest, chalk);
     case 'run':      return runCommand(config, rest, chalk);
     case 'serve':    return serveCommand(config, rest, chalk);
     case 'status':   return statusCommand(config, rest, chalk);
     case 'logs':     return logsCommand(config, rest, chalk);
     case 'down':     return downCommand(config, rest, chalk);
+    case 'restart':   return restartCommand(config, rest, chalk);
+    case 'heartbeat': return heartbeatCommand(config, rest, chalk);
     case 'receipts': return receiptsCommand(config, rest, chalk);
     case 'models':   return modelsCommand(config, chalk);
     case 'capacity': return capacityCommand(config, rest, chalk);

package/src/catalog.js

@@ -112,6 +112,32 @@ export const TEMPLATES = [
       'OpenAI client: OpenAI(base_url="<endpoint>/v1", api_key="<key>")',
     ],
   },
+  {
+    name:        'openwebui',
+    title:       'Open WebUI',
+    description: 'Self-hosted ChatGPT-style web UI for any OpenAI-compatible endpoint',
+    type:        'endpoint',
+    image:       process.env.OPENWEBUI_IMAGE || 'ghcr.io/open-webui/open-webui:main',
+    gpu:         'RTX_3080',
+    gpu_count:   1,
+    port:        8080,
+    health_path: '/health',
+    min_vram_gb: 8,
+    env: {
+      OPENAI_API_BASE_URL: '<set-automatically-by-badgr-serve-openwebui>',
+      OPENAI_API_KEY:      '<your-badgr-api-key>',
+      WEBUI_AUTH:          'False',
+    },
+    notes: [
+      'Preferred: `badgr serve openwebui --model qwen-7b` auto-launches (or reuses) a vLLM',
+      'endpoint and connects Open WebUI to it — no manual env wiring needed.',
+      'Open WebUI is a separate served app from the model — it needs a model endpoint',
+      'behind it (usually vLLM), it is not itself powered by vLLM.',
+      'Or set OPENAI_API_BASE_URL / OPENAI_API_KEY manually via --env to point at any',
+      'OpenAI-compatible server, including one you already have running.',
+      'Chat history and settings persist only for the life of this deployment.',
+    ],
+  },
   {
     name:        'llama-cpp',
     title:       'llama.cpp Server',
@@ -493,6 +519,11 @@ export const BLESSED_COMFY_WORKFLOWS = {
     gpu_type:    'RTX_4090',
     output_type: 'images',
   },
+  'flux-basic': {
+    description: 'FLUX.1-schnell text-to-image',
+    gpu_type:    'RTX_4090',
+    output_type: 'images',
+  },
 };
 
 /**

package/src/commands/comfyui.js

@@ -9,9 +9,10 @@ import { readFileSync, existsSync } from 'fs';
 import { requireApiKey } from '../config.js';
 import { callApi, listDeployments } from '../api.js';
 import { addDeployment, addReceipt, updateReceipt, generateReceiptId } from '../store.js';
-import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
+import { normalizeTier, callWithFallback } from '../fallback.js';
 import { formatCliError } from '../errors.js';
 import { BLESSED_COMFY_WORKFLOWS } from '../catalog.js';
+import { pollJobUntilTerminal, renderJobClosingBlock, stage as _stage, stageDone as _stageDone, writeBlock as _writeBlock, clearBlock as _clearBlock, renderLiveBlock as _renderLiveBlock, printFailureClass as _printFailureClass } from '../progress.js';
 
 const COMFYUI_IMAGE   = process.env.COMFYUI_IMAGE || 'yanwk/comfyui-boot:cu126-megapak';
 const HEALTH_PATH     = '/system_stats';
@@ -54,16 +55,14 @@ function parseEnvFlag(envList) {
   return obj;
 }
 
-function stageLabel(elapsedSec) {
-  if (elapsedSec < 30)  return 'Starting ComfyUI…';
-  if (elapsedSec < 120) return 'Downloading models…';
-  if (elapsedSec < 300) return 'Loading custom nodes…';
-  return `Waiting for ${HEALTH_PATH}…`;
-}
-
-async function waitForComfyUI(endpointUrl, depId, config, chalk) {
+// Live block while ComfyUI comes up — same generic "Checking health" stage
+// line and status block as every other launch path (see serve.js's
+// waitForEndpoint), so ComfyUI doesn't read as a different UX than vLLM.
+async function waitForComfyUI(endpointUrl, depId, config, chalk, costCtx = {}) {
+  const { costPerHour = 0, stageLine = '' } = costCtx;
   const startMs  = Date.now();
   const deadline = startMs + WAIT_TIMEOUT_MS;
+  let blockLines = 0;
 
   while (Date.now() < deadline) {
     try {
@@ -71,22 +70,32 @@ async function waitForComfyUI(endpointUrl, depId, config, chalk) {
         apiKey: config.apiKey, baseUrl: config.baseUrl, timeoutMs: 10_000,
       });
       if (['failed', 'terminated', 'error', 'stopped'].includes(dep.status)) {
-        process.stdout.write('\n');
-        return { ready: false, timedOut: false, depFailed: true, failReason: dep.error || dep.status };
+        if (blockLines > 0) { _clearBlock(blockLines); blockLines = 0; }
+        return {
+          ready: false, timedOut: false, depFailed: true,
+          failReason: dep.error || dep.status,
+          failureClass: dep.failure_class ?? null,
+          nextAction: dep.next_action ?? null,
+        };
       }
     } catch {}
 
     try {
       const res = await fetch(`${endpointUrl}${HEALTH_PATH}`, { signal: AbortSignal.timeout(8000) });
-      if (res.ok) { process.stdout.write('\n'); return { ready: true, timedOut: false, depFailed: false }; }
+      if (res.ok) {
+        if (blockLines > 0) { _clearBlock(blockLines); blockLines = 0; }
+        return { ready: true, timedOut: false, depFailed: false };
+      }
     } catch {}
 
-    const elapsed = Math.round((Date.now() - startMs) / 1000);
-    process.stdout.write(`\r  ${chalk.dim(stageLabel(elapsed) + ` (${elapsed}s)`)}   `);
+    const elapsedSec = Math.round((Date.now() - startMs) / 1000);
+    const spend = costPerHour * (elapsedSec / 3600);
+    blockLines = _writeBlock(blockLines, _renderLiveBlock(chalk, {
+      stageLine, elapsedSec, statusWord: 'starting', spend, id: depId,
+    }));
     await new Promise(r => setTimeout(r, 8000));
   }
 
-  process.stdout.write('\n');
   return { ready: false, timedOut: true, depFailed: false };
 }
 
@@ -142,7 +151,7 @@ export async function comfyBatchCommand(config, args, chalk) {
   if (!flags.workflow) {
     console.error(chalk.red('\n  Usage: badgr comfyui batch --workflow sdxl-basic --prompts prompts.txt --max-cost 10\n'));
     console.error(chalk.dim('  Runs a batch of prompts through a blessed ComfyUI workflow and returns image URLs.\n'));
-    console.error(chalk.dim('  Blessed workflows: sdxl-basic\n'));
+    console.error(chalk.dim(`  Blessed workflows: ${Object.keys(BLESSED_COMFY_WORKFLOWS).join(', ')}\n`));
     process.exitCode = 1;
     return;
   }
@@ -232,36 +241,30 @@ export async function comfyBatchCommand(config, args, chalk) {
   console.log(`  ${chalk.bold('Receipt:')} ${chalk.dim(rcptId)}`);
   console.log(chalk.dim('\n  Polling for completion…\n'));
 
-  const startMs = Date.now();
   const maxMs = maxRuntime * 60 * 1000;
-  while (Date.now() - startMs < maxMs) {
-    await new Promise(r => setTimeout(r, 15_000));
-    let detail;
-    try {
-      detail = await callApi(`/jobs/${job.job_id}`, {
-        apiKey: config.apiKey,
-        baseUrl: config.baseUrl,
-      });
-    } catch { continue; }
-    process.stdout.write(`\r  Status: ${detail.status}  elapsed: ${Math.floor((Date.now() - startMs) / 1000)}s  `);
-    if (detail.status === 'completed') {
-      const out = detail.output || {};
-      console.log(chalk.green('\n\n  ✓ Batch complete\n'));
-      if (out.image_urls && out.image_urls.length > 0) {
-        console.log(`  ${chalk.bold('Images (${out.image_urls.length}):')}`);
-        out.image_urls.forEach((url, i) => console.log(`    ${i + 1}. ${url}`));
-      }
-      console.log(`\n  ${chalk.bold('Receipt:')} ${chalk.dim(rcptId)}\n`);
-      return;
-    }
-    if (detail.status === 'failed') {
-      console.error(chalk.red(`\n\n  ✗ Batch failed: ${detail.error_code || ''} — ${detail.error_message || ''}\n`));
-      process.exitCode = 1;
-      return;
+  const { outcome, detail } = await pollJobUntilTerminal(callApi, config, job.job_id, { chalk, maxMs });
+
+  if (outcome === 'polling_failed') {
+    console.error(chalk.red(`\n\n  ✗ Lost contact with Badgr — could not confirm job status.\n`));
+    console.error(chalk.dim(`    badgr status\n    badgr logs ${job.job_id}\n`));
+    process.exitCode = 1;
+    return;
+  }
+  if (outcome === 'timed_out') {
+    console.error(chalk.yellow('\n\n  Batch still running — detached. Check status:\n'));
+    console.error(chalk.dim(`    badgr status\n`));
+    return;
+  }
+
+  if (outcome === 'completed') {
+    const out = detail.output || {};
+    if (out.image_urls && out.image_urls.length > 0) {
+      console.log(`\n  ${chalk.bold(`Images (${out.image_urls.length}):`)}`);
+      out.image_urls.forEach((url, i) => console.log(`    ${i + 1}. ${url}`));
     }
   }
-  console.error(chalk.yellow('\n\n  Batch still running — detached. Check status:\n'));
-  console.error(chalk.dim(`    badgr status\n`));
+  console.log(renderJobClosingBlock(chalk, detail, rcptId));
+  if (outcome === 'failed') process.exitCode = 1;
 }
 
 export async function comfyuiCommand(config, args, chalk) {
@@ -322,7 +325,10 @@ export async function comfyuiCommand(config, args, chalk) {
   const effectiveTier = normalizeTier(flags.tier);
   const envObj        = { ...parseEnvFlag(flags.env), COMFYUI_WORKFLOW_B64: workflowB64 };
 
-  console.log(chalk.bold('\n🎨 ComfyUI\n'));
+  const STAGE_TOTAL = 4;
+  let stageN = 1;
+
+  console.log(chalk.bold('\n⚡ Running ComfyUI\n'));
   console.log(`  ${chalk.bold('Workflow:')} ${workflow} (${nodeCount} nodes)`);
   console.log(`  ${chalk.bold('Image:')}    ${COMFYUI_IMAGE}`);
   console.log(`  ${chalk.bold('GPU:')}      ${gpu === 'AUTO' ? chalk.dim('auto (16+ GB VRAM)') : gpu}`);
@@ -332,7 +338,6 @@ export async function comfyuiCommand(config, args, chalk) {
     console.log(chalk.yellow('  ⚠  Persistent — billing until: badgr down <id>'));
   }
   console.log();
-  process.stdout.write(chalk.dim('  Finding suitable capacity...\n'));
 
   // Duplicate check
   if (config.apiKey) {
@@ -412,6 +417,11 @@ export async function comfyuiCommand(config, args, chalk) {
     createdAt:     new Date().toISOString(),
   });
 
+  console.log(chalk.dim(_stageDone(stageN, STAGE_TOTAL, 'Finding a working route...')));
+  stageN++;
+  console.log(chalk.dim(_stageDone(stageN, STAGE_TOTAL, 'Starting runtime...')));
+  stageN++;
+
   const endpointUrl = dep.endpoint_url || dep.openai_base_url;
   if (!endpointUrl) {
     console.error(chalk.red(`\n  ✗ No endpoint URL returned. Run: badgr status ${dep.deployment_id}\n`));
@@ -420,25 +430,36 @@ export async function comfyuiCommand(config, args, chalk) {
     return;
   }
 
+  const healthStageN = stageN;
+  const readyStageN  = stageN + 1;
+
   let endpointReady = false;
   if (flags.noWait) {
-    console.log(chalk.yellow('\n  Skipped health check (--no-wait)\n'));
+    console.log(chalk.dim(_stage(healthStageN, STAGE_TOTAL, 'Checking health...')) + chalk.yellow('  (skipped — --no-wait)'));
   } else {
-    const result = await waitForComfyUI(endpointUrl, dep.deployment_id, config, chalk);
-    process.stdout.write('\n');
+    const stageLine = _stage(healthStageN, STAGE_TOTAL, 'Checking health...');
+    const result = await waitForComfyUI(endpointUrl, dep.deployment_id, config, chalk, {
+      costPerHour: dep.cost_per_hour || 0, stageLine,
+    });
 
     if (result.depFailed) {
       console.error(formatCliError('HEALTH_CHECK_DEPLOY_FAILED', {
         deploymentId: dep.deployment_id,
         failReason:   result.failReason,
       }, chalk));
+      _printFailureClass(chalk, { failure_class: result.failureClass, next_action: result.nextAction });
       updateReceipt(rcptId, { status: 'failed', failReason: result.failReason });
       process.exitCode = 1;
       return;
     }
 
     endpointReady = result.ready;
-    if (!endpointReady) updateReceipt(rcptId, { status: 'health_check_timeout' });
+    if (endpointReady) {
+      console.log(chalk.dim(_stage(healthStageN, STAGE_TOTAL, 'Checking health...')));
+      console.log(chalk.green(_stage(readyStageN, STAGE_TOTAL, 'Ready')));
+    } else {
+      updateReceipt(rcptId, { status: 'health_check_timeout' });
+    }
   }
 
   if (flags.checkNodes && endpointReady) {
@@ -460,18 +481,11 @@ export async function comfyuiCommand(config, args, chalk) {
     console.log();
   }
 
-  const rate = dep.cost_per_hour || 0;
   console.log(`  ${chalk.bold('URL:')}          ${chalk.cyan(endpointUrl)}`);
-  console.log(`  ${chalk.bold('GPU:')}          ${dep.gpu_type} × ${dep.gpu_count}`);
-  if (rate > 0)       console.log(`  ${chalk.bold('Rate:')}         $${rate.toFixed(2)}/hr`);
   if (flags.maxCost)  console.log(`  ${chalk.bold('Max cost:')}     $${flags.maxCost.toFixed(2)}`);
   console.log(`  ${chalk.bold('Receipt:')}      ${chalk.dim(rcptId)}`);
   console.log(`  ${chalk.bold('Logs:')}         ${chalk.dim(`badgr logs ${dep.deployment_id}`)}`);
   console.log(`  ${chalk.bold('Stop billing:')} ${chalk.cyan(`badgr down ${dep.deployment_id}`)}`);
   console.log();
-
-  if (rate > HIGH_RATE_THRESHOLD && !flags.maxCost) {
-    console.log(chalk.yellow(`  Rate: $${rate.toFixed(2)}/hr — use --max-cost to cap total spend.\n`));
-  }
   console.log(chalk.dim('  Billing continues until you run: ') + chalk.cyan(`badgr down ${dep.deployment_id}`));
 }

package/src/commands/detect.js

@@ -0,0 +1,58 @@
+import path from 'path';
+import { detectWorkload, workloadTypeLabel } from '../detect.js';
+
+function fmtList(items, empty = 'none found') {
+  return items && items.length ? items.join(', ') : empty;
+}
+
+export function suggestedCommandLine(report, { save } = {}) {
+  const parts = ['badgr run .'];
+  if (report.command) parts.push(`--cmd "${report.command}"`);
+  if (report.outputs?.length) parts.push(`--output ${report.outputs[0]}`);
+  if (report.checkpoints?.length) parts.push(`--checkpoint ${report.checkpoints[0]}`);
+  parts.push('--max-cost 5');
+  if (save) parts.push(`--save ${save}`);
+  return parts.join(' ');
+}
+
+export function renderDetectReport(report, chalk) {
+  const lines = [];
+  lines.push('');
+  lines.push(chalk.bold(`Workload:    ${workloadTypeLabel(report.workloadType)}`));
+  const confColor = report.confidence === 'high' ? chalk.green : report.confidence === 'medium' ? chalk.yellow : chalk.red;
+  lines.push(`Confidence:  ${confColor(report.confidence)}`);
+  lines.push('');
+  lines.push(`Detected command:        ${report.command ? chalk.cyan(report.command) : chalk.dim('(none — pass --cmd)')}`);
+  if (report.dockerfile) lines.push(`Detected image:          Dockerfile (${report.dockerfile})`);
+  if (report.requirements.length) lines.push(`Detected requirements:   ${fmtList(report.requirements)}`);
+  lines.push(`Detected inputs:         ${fmtList(report.inputs)}`);
+  lines.push(`Detected outputs:        ${fmtList(report.outputs)}`);
+  if (report.checkpoints.length) lines.push(`Detected checkpoints:    ${fmtList(report.checkpoints)}`);
+  lines.push(`Detected models/assets:  ${fmtList(report.models)}`);
+  if (report.ports.length) lines.push(`Detected ports:          ${report.ports.join(', ')}`);
+  lines.push(`Estimated VRAM:          ${report.vram}`);
+  lines.push(`Estimated runtime:       ${report.runtimeEstimateMinutes != null ? `${report.runtimeEstimateMinutes} min` : 'until stopped (endpoint)'}`);
+  if (report.signals.length) {
+    lines.push('');
+    lines.push(chalk.dim(`Why: ${report.signals.join('; ')}`));
+  }
+  lines.push('');
+  lines.push(`Suggested Badgr command:`);
+  lines.push(`  ${chalk.cyan(suggestedCommandLine(report))}`);
+  lines.push('');
+  return lines.join('\n');
+}
+
+export async function detectCommand(config, args, chalk) {
+  const target = args.find(a => !a.startsWith('--')) || '.';
+  const report = detectWorkload(target);
+
+  if (report.error) {
+    console.error(chalk.red(`\n  ✗ ${report.error}: ${path.resolve(target)}\n`));
+    process.exitCode = 1;
+    return report;
+  }
+
+  console.log(renderDetectReport(report, chalk));
+  return report;
+}

package/src/commands/heartbeat.js

@@ -0,0 +1,38 @@
+import { requireApiKey } from '../config.js';
+import { findDeployment } from '../store.js';
+import { heartbeatDeployment } from '../api.js';
+
+/**
+ * badgr heartbeat <deployment-id|name>
+ *
+ * Resets an endpoint's idle-timeout clock. Badgr doesn't proxy inference
+ * traffic, so if you set --idle-timeout on `badgr serve`, call this on
+ * each real request (or wire it into your own client) — otherwise the
+ * endpoint is torn down once idle_timeout_minutes elapses, even if it's
+ * still reachable.
+ */
+export async function heartbeatCommand(config, args, chalk) {
+  const idOrName = args.find(a => !a.startsWith('--'));
+
+  if (!idOrName) {
+    console.error(chalk.red('Usage: badgr heartbeat <deployment-id|name>'));
+    console.error(chalk.dim('       Resets the idle-timeout clock for an endpoint launched with --idle-timeout.'));
+    return;
+  }
+
+  requireApiKey(config);
+
+  const localDep     = findDeployment(idOrName);
+  const deploymentId = localDep?.id ?? idOrName;
+
+  try {
+    const result = await heartbeatDeployment(config, deploymentId);
+    console.log(chalk.green(`  ✓ Heartbeat recorded for ${deploymentId}`));
+    if (result.last_activity_at) {
+      console.log(chalk.dim(`    last_activity_at: ${new Date(result.last_activity_at * 1000).toISOString()}`));
+    }
+  } catch (err) {
+    console.error(chalk.red(`  ✗ Could not send heartbeat: ${err.message}`));
+    process.exitCode = 1;
+  }
+}

package/src/commands/receipts.js

@@ -1,5 +1,5 @@
-import { listReceipts as localReceipts } from '../store.js';
-import { listReceipts as apiReceipts, getReceipt as apiGetReceipt } from '../api.js';
+import { listReceipts as localReceipts, findReceipt } from '../store.js';
+import { listReceipts as apiReceipts, getReceipt as apiGetReceipt, getJobStatus } from '../api.js';
 
 function fmtMs(ms) {
   return ms >= 1000 ? `${(ms / 1000).toFixed(1)}s` : `${ms}ms`;
@@ -54,6 +54,43 @@ export async function receiptsCommand(config, args, chalk) {
       console.log(chalk.dim('  Run `badgr login` to look up receipts from the API.\n'));
       return;
     }
+
+    // Job-family receipts (badgr comfyui batch / train lora / run / serve)
+    // mint a *local* receipt id that points at a job_id — the backend's
+    // /v1/receipts endpoint has never heard of it (that's the separate LLM
+    // inference receipt ledger), so look it up via the job's own status
+    // instead of 404ing against the wrong system.
+    const local = findReceipt(firstArg);
+    if (local?.job_id) {
+      try {
+        const job = await getJobStatus(config, local.job_id);
+        if (job.status === 'queued' || job.status === 'provisioning' || job.status === 'running' || job.status === 'tearing_down') {
+          console.log(chalk.yellow('  Receipt is still finalizing. Try again shortly.\n'));
+          console.log(`    ${chalk.bold('Job ID:')} ${local.job_id}  (status: ${job.status})\n`);
+          return;
+        }
+        printReceipt({
+          receiptId: firstArg,
+          action: local.type,
+          status: job.status,
+          created_at: new Date(local.started_at || Date.now()).toISOString(),
+          runtimeSeconds: job.elapsed_seconds,
+          finalCost: job.charged_usd ?? undefined,
+          failure_reason: job.failure_class,
+        }, chalk);
+        console.log(`    ${chalk.bold('Teardown:')} ${job.teardown_status === 'ok' ? 'succeeded' : job.teardown_status === 'failed' ? 'failed' : 'n/a'}`);
+        console.log(`    ${chalk.bold('Billing:')}  ${job.billing_status === 'stopped' ? 'stopped' : 'running'}\n`);
+      } catch (err) {
+        // The job finished (we have a local record of a terminal receipt),
+        // but the backend can't confirm it right now — don't silently show
+        // nothing, since billing may or may not actually be settled.
+        console.log(chalk.yellow('  Billing stopped, but receipt finalization failed.\n'));
+        console.log(`    ${chalk.bold('Job ID:')} ${local.job_id}`);
+        console.log(chalk.dim('    Contact support with this ID.\n'));
+      }
+      return;
+    }
+
     try {
       const r = await apiGetReceipt(config, firstArg);
       printReceipt(r, chalk);

package/src/commands/restart.js

@@ -0,0 +1,74 @@
+import { requireApiKey } from '../config.js';
+import { findDeployment, removeDeployment, addDeployment, addReceipt, generateReceiptId } from '../store.js';
+import { restartDeployment } from '../api.js';
+
+/**
+ * badgr restart <deployment-id|name>
+ *
+ * Tears down the current pod and relaunches an endpoint with the same
+ * config (GPU, model, price/cost/runtime caps, endpoint API key). Returns
+ * a *new* deployment_id and endpoint_url — the old pod's IP is gone.
+ */
+export async function restartCommand(config, args, chalk) {
+  const idOrName = args.find(a => !a.startsWith('--'));
+
+  if (!idOrName) {
+    console.error(chalk.red('Usage: badgr restart <deployment-id|name>'));
+    return;
+  }
+
+  requireApiKey(config);
+
+  const localDep     = findDeployment(idOrName);
+  const deploymentId = localDep?.id ?? idOrName;
+
+  process.stdout.write(chalk.dim(`  Restarting ${deploymentId}...`));
+
+  let dep;
+  try {
+    dep = await restartDeployment(config, deploymentId);
+  } catch (err) {
+    process.stdout.write('\n');
+    console.error(chalk.red(`\n  ✗ Could not restart deployment: ${err.message}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  process.stdout.write('\n');
+
+  removeDeployment(idOrName);
+  addDeployment({
+    id:          dep.deployment_id,
+    name:        dep.name,
+    type:        dep.workload_type,
+    model:       dep.model,
+    gpu:         dep.gpu_type,
+    count:       dep.gpu_count,
+    status:      dep.status,
+    endpointUrl: dep.endpoint_url || dep.openai_base_url,
+    receiptId:   dep.receipt_id,
+    createdAt:   new Date().toISOString(),
+    costPerHour: dep.cost_per_hour || 0,
+    providerRoute: dep.provider ?? null,
+    tier:          dep.tier ?? null,
+  });
+
+  const rcptId = dep.receipt_id || generateReceiptId();
+  addReceipt({
+    receiptId:    rcptId,
+    action:       'badgr restart',
+    deploymentId: dep.deployment_id,
+    gpu:          dep.gpu_type,
+    status:       dep.status,
+    createdAt:    new Date().toISOString(),
+  });
+
+  const endpointUrl = dep.endpoint_url || dep.openai_base_url;
+  console.log(chalk.green('\n  ✓ Restarted\n'));
+  console.log(`  ${chalk.bold('New deployment:')} ${chalk.cyan(dep.deployment_id)}`);
+  if (endpointUrl) console.log(`  ${chalk.bold('New base URL:')}   ${chalk.cyan(endpointUrl)}`);
+  console.log(chalk.dim('  Old endpoint URL is gone — update any client pointed at it.'));
+  console.log(chalk.dim('  Your endpoint API key is unchanged — no need to re-issue it.'));
+  console.log(`  ${chalk.bold('Status:')}         badgr status ${dep.deployment_id}`);
+  console.log();
+}