badgr-cli 1.0.43 → 1.0.45

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',
@@ -471,6 +497,21 @@ export const BLESSED_VLLM_MODELS = {
   },
 };
 
+// Hugging Face org/model prefixes that are known to gate access behind a license
+// click-through. Used only to print a helpful HF_TOKEN hint — not exhaustive.
+const GATED_MODEL_PREFIXES = [
+  'meta-llama/',
+  'google/gemma',
+  'mistralai/Mistral-Large',
+  'mistralai/Mixtral-8x22B',
+];
+
+/** Best-effort heuristic: is this HF model ID likely to require HF_TOKEN? */
+export function isLikelyGatedModel(modelId) {
+  if (!modelId) return false;
+  return GATED_MODEL_PREFIXES.some(prefix => modelId.startsWith(prefix));
+}
+
 /** Blessed ComfyUI workflows accepted by `POST /v1/jobs` comfy.batch. */
 export const BLESSED_COMFY_WORKFLOWS = {
   'sdxl-basic': {
@@ -478,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/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);