badgr-cli 1.0.35 → 1.0.37

package/README.md

@@ -51,6 +51,13 @@ badgr down <deployment-id>
 
 `badgr run` — for anything that starts, runs, and exits: batch inference, fine-tuning, evals, image/video batch jobs, audio processing.
 
+**Shortcuts** — wrappers around `run` / `serve` for common workloads:
+
+| `badgr comfyui run <workflow.json>` | Launch ComfyUI, queue workflow, return endpoint URL |
+| `badgr train <config.yaml>` | LoRA / fine-tuning job, stream logs |
+| `badgr transcribe <audio>` | Whisper transcription, print transcript |
+| `badgr embed <model> <input>` | Text embeddings, output JSONL |
+
 ---
 
 ## `badgr serve` options
@@ -97,6 +104,101 @@ badgr run python train.py --gpu A100 --env HF_TOKEN=$HF_TOKEN --max-runtime 60
 
 ---
 
+## `badgr comfyui run` options
+
+```bash
+badgr comfyui run workflow.json --max-cost 10
+badgr comfyui run workflow.json --gpu RTX_4090 --check-nodes KSampler,CLIPTextEncode
+```
+
+Requires either `--max-cost` or `--persistent` to prevent runaway billing.
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--gpu <type>` | auto (16+ GB VRAM) | GPU type override |
+| `--max-cost <$>` | — | Auto-stop when total spend reaches this amount |
+| `--max-price <$/hr>` | — | Hard spend cap per GPU-hour |
+| `--tier 1\|2` | 1 | Provider tier |
+| `--region US\|EU\|AU` | — | Region preference |
+| `--check-nodes <n1,n2>` | — | Verify custom nodes are installed after startup |
+| `--no-wait` | — | Skip health check, return immediately |
+| `--persistent` | — | Run until manually stopped (no spending cap) |
+| `--env KEY=VALUE` | — | Environment variable (repeatable) |
+| `--yes` / `-y` | — | Skip duplicate-deployment warning |
+
+---
+
+## `badgr train` options
+
+```bash
+badgr train config.yaml --gpu A100 --max-runtime 240 --env HF_TOKEN=$HF_TOKEN
+```
+
+Auto-detects framework (axolotl, unsloth, trl) from config content. Default max-runtime is 120 min.
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--gpu <type>` | auto (40+ GB VRAM preferred) | GPU type override |
+| `--max-runtime <min>` | 120 | Auto-stop after N minutes |
+| `--max-cost <$>` | — | Auto-stop when total spend reaches this amount |
+| `--max-price <$/hr>` | — | Hard spend cap per GPU-hour |
+| `--tier 1\|2` | 1 | Provider tier |
+| `--region US\|EU\|AU` | — | Region preference |
+| `--framework <name>` | auto-detect | Force framework: `axolotl`, `unsloth`, `trl` |
+| `--env KEY=VALUE` | — | Environment variable (repeatable) |
+| `--detach` | — | Launch and return immediately, don't stream logs |
+
+---
+
+## `badgr transcribe` options
+
+```bash
+badgr transcribe recording.mp3 --max-cost 2
+badgr transcribe s3://bucket/meeting.mp3 --model large-v3 --language en
+```
+
+Accepts a public URL, S3/GCS URI, or a local file under 50 MB. Default max-runtime is 30 min.
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--model <name>` | `large-v3` | Whisper model |
+| `--gpu <type>` | auto (8+ GB VRAM) | GPU type override |
+| `--language <code>` | — | Language hint (e.g. `en`, `fr`) |
+| `--output <format>` | — | Output format: `txt`, `srt`, `vtt` |
+| `--max-runtime <min>` | 30 | Auto-stop after N minutes |
+| `--max-cost <$>` | — | Auto-stop when total spend reaches this amount |
+| `--max-price <$/hr>` | — | Hard spend cap per GPU-hour |
+| `--tier 1\|2` | 1 | Provider tier |
+| `--region US\|EU\|AU` | — | Region preference |
+| `--env KEY=VALUE` | — | Environment variable (repeatable) |
+| `--detach` | — | Launch and return immediately, don't stream logs |
+
+---
+
+## `badgr embed` options
+
+```bash
+badgr embed BAAI/bge-large-en-v1.5 documents.txt --max-cost 2
+badgr embed BAAI/bge-large-en-v1.5 s3://bucket/corpus.jsonl
+badgr embed documents.txt   # uses default model
+```
+
+Accepts a public URL, S3/GCS URI, or a local text file under 10 MB. Outputs JSONL (`{"text": ..., "embedding": [...]}`). Default max-runtime is 30 min.
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--gpu <type>` | auto (8+ GB VRAM) | GPU type override |
+| `--batch-size <n>` | — | Embedding batch size |
+| `--max-runtime <min>` | 30 | Auto-stop after N minutes |
+| `--max-cost <$>` | — | Auto-stop when total spend reaches this amount |
+| `--max-price <$/hr>` | — | Hard spend cap per GPU-hour |
+| `--tier 1\|2` | 1 | Provider tier |
+| `--region US\|EU\|AU` | — | Region preference |
+| `--env KEY=VALUE` | — | Environment variable (repeatable) |
+| `--detach` | — | Launch and return immediately, don't stream logs |
+
+---
+
 ## Routing
 
 Badgr Auto selects the best eligible route based on GPU type, VRAM, availability, region, workload requirements, and reliability. Advanced users can optionally choose an execution tier or hardware constraint.

package/package.json

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

package/src/badgr.js

@@ -1,18 +1,22 @@
 #!/usr/bin/env node
 import chalk from 'chalk';
 import { loadConfig, saveConfig } from './config.js';
-import { loginCommand }    from './commands/login.js';
-import { upCommand }       from './commands/up.js';
-import { downCommand }     from './commands/down.js';
-import { statusCommand }   from './commands/status.js';
-import { logsCommand }     from './commands/logs.js';
-import { receiptsCommand } from './commands/receipts.js';
-import { runCommand }      from './commands/run.js';
-import { serveCommand }    from './commands/serve.js';
-import { modelsCommand }   from './commands/models.js';
-import { capacityCommand } from './commands/capacity.js';
-import { testCommand }     from './commands/test-run.js';
-import { billingCommand }  from './commands/billing.js';
+import { loginCommand }      from './commands/login.js';
+import { upCommand }         from './commands/up.js';
+import { downCommand }       from './commands/down.js';
+import { statusCommand }     from './commands/status.js';
+import { logsCommand }       from './commands/logs.js';
+import { receiptsCommand }   from './commands/receipts.js';
+import { runCommand }        from './commands/run.js';
+import { serveCommand }      from './commands/serve.js';
+import { modelsCommand }     from './commands/models.js';
+import { capacityCommand }   from './commands/capacity.js';
+import { testCommand }       from './commands/test-run.js';
+import { billingCommand }    from './commands/billing.js';
+import { comfyuiCommand }    from './commands/comfyui.js';
+import { trainCommand }      from './commands/train.js';
+import { transcribeCommand } from './commands/transcribe.js';
+import { embedCommand }      from './commands/embed.js';
 
 const HELP = `
 ${chalk.bold('badgr')} — run or serve GPU workloads from one command
@@ -29,33 +33,37 @@ ${chalk.bold('COMMANDS')}
   ${chalk.cyan('badgr capacity')}            Check what GPU capacity is available right now
   ${chalk.cyan('badgr billing')}             Show balance and add funds
 
+${chalk.bold('SHORTCUTS')}  ${chalk.dim('(wrappers around run / serve for common workloads)')}
+  ${chalk.cyan('badgr comfyui run <workflow.json>')}   Launch ComfyUI, return endpoint URL
+  ${chalk.cyan('badgr train <config.yaml>')}           LoRA / fine-tuning job, stream logs
+  ${chalk.cyan('badgr transcribe <audio>')}            Whisper transcription, print transcript
+  ${chalk.cyan('badgr embed <model> <input>')}         Text embeddings, output JSONL
+
 ${chalk.bold('EXAMPLES')}
   ${chalk.dim('# Verify the stack works end-to-end:')}
   badgr test
 
-  ${chalk.dim('# Tier 1 — managed provider routing (default):')}
-  badgr run python train.py
-  badgr serve meta-llama/Llama-3.1-8B-Instruct
+  ${chalk.dim('# Serve a model (OpenAI-compatible):')}
+  badgr serve meta-llama/Llama-3.1-8B-Instruct --max-cost 10
 
-  ${chalk.dim('# Tier 2 — marketplace routing, lower-cost options:')}
-  badgr run python train.py --tier 2
-  badgr serve meta-llama/Llama-3.1-8B-Instruct --tier 2
+  ${chalk.dim('# Launch ComfyUI with a workflow:')}
+  badgr comfyui run workflow.json --max-cost 5
 
-  ${chalk.dim('# Pin a specific GPU:')}
-  badgr run python train.py --gpu A100
-  badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S
+  ${chalk.dim('# LoRA fine-tuning:')}
+  badgr train axolotl_config.yaml --max-runtime 120
 
-  ${chalk.dim('# Pass environment variables:')}
-  badgr run python train.py --env HF_TOKEN=$HF_TOKEN --env DATASET=my/data
+  ${chalk.dim('# Transcribe audio (URL or local file ≤50 MB):')}
+  badgr transcribe s3://my-bucket/meeting.mp3 --max-cost 2
+  badgr transcribe recording.mp3
 
-  ${chalk.dim('# Serve an embedding model:')}
-  badgr serve BAAI/bge-large-en-v1.5 --task embed
+  ${chalk.dim('# Generate embeddings:')}
+  badgr embed BAAI/bge-large-en-v1.5 documents.txt --max-cost 2
 
-  ${chalk.dim('# Serve a custom container (Diffusers, Whisper, etc.):')}
-  badgr serve --image ghcr.io/my-org/diffusers-api:latest --gpu L40S --env MODEL_ID=flux
+  ${chalk.dim('# Tier 2 — marketplace routing, lower-cost options:')}
+  badgr serve meta-llama/Llama-3.1-8B-Instruct --tier 2 --max-cost 10
 
-  ${chalk.dim('# Add safety caps:')}
-  badgr run python train.py --max-runtime 60 --max-cost 5
+  ${chalk.dim('# Pin a specific GPU:')}
+  badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S --max-cost 10
 
   ${chalk.dim('# Manage a running deployment:')}
   badgr status
@@ -120,9 +128,13 @@ async function main() {
     case 'models':   return modelsCommand(config, chalk);
     case 'capacity': return capacityCommand(config, rest, chalk);
     case 'test':     return testCommand(config, rest, chalk);
-    case 'billing':  return billingCommand(config, rest, chalk);
+    case 'billing':    return billingCommand(config, rest, chalk);
+    case 'comfyui':   return comfyuiCommand(config, rest, chalk);
+    case 'train':     return trainCommand(config, rest, chalk);
+    case 'transcribe': return transcribeCommand(config, rest, chalk);
+    case 'embed':     return embedCommand(config, rest, chalk);
     // legacy aliases kept for compatibility
-    case 'up':       return upCommand(config, rest, chalk);
+    case 'up':        return upCommand(config, rest, chalk);
     case 'config': {
       const { apiKey, ...safe } = config;
       const display = { ...safe, apiKey: apiKey ? `${apiKey.slice(0, 8)}...` : '(not set)' };

package/src/batch.js

@@ -0,0 +1,157 @@
+/**
+ * Shared batch job monitor.
+ *
+ * After a /run job is provisioned, this module handles:
+ *   wait for container start → stream logs → enforce spend/runtime caps → teardown
+ *
+ * Used by: badgr train, badgr transcribe, badgr embed
+ */
+import { callApi, terminateDeployment } from './api.js';
+import { updateReceipt } from './store.js';
+import { formatCliError } from './errors.js';
+
+// Log lines that carry telemetry metadata, not user output.
+const LOG_META_RE = /^\[dep-[^\]]+\] (status|gpu|region|cost|receipt|provider_status|uptime)=/;
+
+export function fmtRuntime(ms) {
+  const s = Math.round(ms / 1000);
+  return s < 60 ? `${s}s` : `${Math.floor(s / 60)}m ${s % 60}s`;
+}
+
+const STARTUP  = new Set(['queued', 'provisioning', 'starting']);
+const TERMINAL = new Set(['stopped', 'failed', 'completed', 'succeeded']);
+
+async function waitForRunning(config, depId, chalk) {
+  const POLL_MS    = 3000;
+  const TIMEOUT_MS = 5 * 60 * 1000;
+  const startMs    = Date.now();
+
+  process.stdout.write(chalk.dim('  Starting container'));
+  while (Date.now() - startMs < TIMEOUT_MS) {
+    await new Promise(r => setTimeout(r, POLL_MS));
+    let dep;
+    try {
+      dep = await callApi(`/deployments/${depId}`, {
+        apiKey: config.apiKey, baseUrl: config.baseUrl, timeoutMs: 10_000,
+      });
+    } catch { process.stdout.write('.'); continue; }
+    if (!STARTUP.has(dep.status)) { process.stdout.write('\n'); return dep; }
+    process.stdout.write('.');
+  }
+  process.stdout.write('\n');
+  return callApi(`/deployments/${depId}`, {
+    apiKey: config.apiKey, baseUrl: config.baseUrl, timeoutMs: 10_000,
+  });
+}
+
+/**
+ * Monitor a running batch job until completion, cap, or interrupt.
+ *
+ * Installs a SIGINT handler — callers must not install their own.
+ *
+ * @param {object} config
+ * @param {string} depId
+ * @param {string} rcptId
+ * @param {{chalk, maxRuntimeMs, maxCost, ratePerHour}} opts
+ * @returns {Promise<{ status, exitCode, runtimeMs, reason }>}
+ */
+export async function monitorBatchJob(config, depId, rcptId, opts) {
+  const { chalk, maxRuntimeMs, maxCost, ratePerHour } = opts;
+  const POLL_MS = 5000;
+
+  const startDep = await waitForRunning(config, depId, chalk);
+
+  if (startDep.status === 'failed') {
+    updateReceipt(rcptId, { status: 'failed', runtimeSeconds: 0, finalCost: 0 });
+    console.error(formatCliError('JOB_INFRASTRUCTURE_FAILURE', { receiptId: rcptId }, chalk));
+    return { status: 'failed', exitCode: null, runtimeMs: 0, reason: 'infrastructure' };
+  }
+
+  console.log(chalk.dim('\n  ── Running (Ctrl+C to stop) ─────────────────────────────────────\n'));
+
+  const seenLines   = new Set();
+  const attachStart = Date.now();
+  let tearing       = false;
+  let shuttingDown  = false;
+
+  function handleSIGINT() { shuttingDown = true; }
+  process.once('SIGINT', handleSIGINT);
+
+  async function teardown(reason) {
+    if (tearing) return;
+    tearing = true;
+    const msgs = {
+      'max-runtime': chalk.yellow('\n  ⏱ Max runtime reached — stopping...'),
+      'max-cost':    chalk.yellow('\n  💰 Spend cap reached — stopping...'),
+      'interrupted': chalk.yellow('\n  Stopping...'),
+    };
+    console.log(msgs[reason] ?? chalk.yellow('\n  Stopping...'));
+    try { await terminateDeployment(config, depId); } catch {}
+    const runtimeMs = Date.now() - attachStart;
+    const finalCost = ratePerHour * (runtimeMs / 3_600_000);
+    updateReceipt(rcptId, {
+      status:         reason,
+      runtimeSeconds: Math.round(runtimeMs / 1000),
+      finalCost,
+    });
+    console.log(chalk.dim(`  Runtime: ${fmtRuntime(runtimeMs)}  •  Est. cost: $${finalCost.toFixed(4)}`));
+    console.log(chalk.dim('  Stopped. Billing ended.\n'));
+  }
+
+  while (true) {
+    if (shuttingDown || tearing) break;
+    await new Promise(r => setTimeout(r, POLL_MS));
+    if (shuttingDown || tearing) break;
+
+    const elapsed = Date.now() - attachStart;
+    const spent   = ratePerHour * (elapsed / 3_600_000);
+
+    if (maxCost !== null && spent >= maxCost) { await teardown('max-cost');    break; }
+    if (elapsed >= maxRuntimeMs)              { await teardown('max-runtime'); break; }
+
+    let dep;
+    try {
+      dep = await callApi(`/deployments/${depId}`, {
+        apiKey: config.apiKey, baseUrl: config.baseUrl, timeoutMs: 10_000,
+      });
+    } catch { continue; }
+
+    try {
+      const logData = await callApi(`/deployments/${depId}/logs`, {
+        apiKey: config.apiKey, baseUrl: config.baseUrl, timeoutMs: 10_000,
+      });
+      for (const line of (logData?.logs ?? [])) {
+        if (seenLines.has(line)) continue;
+        seenLines.add(line);
+        if (LOG_META_RE.test(line)) continue;
+        if (/\b(gpu_util|cpu_util|provider_status|uptime)=/.test(line)) continue;
+        const isErr = /^error\b/i.test(line) || /Error response from daemon/i.test(line);
+        console.log(`  ${isErr ? chalk.red(line) : chalk.dim(line)}`);
+      }
+    } catch {}
+
+    if (TERMINAL.has(dep.status)) {
+      process.removeListener('SIGINT', handleSIGINT);
+      const exitCode  = dep.exit_code ?? null;
+      const runtimeMs = Date.now() - attachStart;
+      const finalCost = ratePerHour * (runtimeMs / 3_600_000);
+      try { await terminateDeployment(config, depId); } catch {}
+      updateReceipt(rcptId, {
+        status:         dep.status,
+        exitCode,
+        runtimeSeconds: Math.round(runtimeMs / 1000),
+        finalCost,
+      });
+      return { status: dep.status, exitCode, runtimeMs, reason: 'complete' };
+    }
+  }
+
+  process.removeListener('SIGINT', handleSIGINT);
+
+  if (shuttingDown) {
+    await teardown('interrupted');
+    return { status: 'interrupted', exitCode: null, runtimeMs: Date.now() - attachStart, reason: 'interrupted' };
+  }
+
+  return { status: 'capped', exitCode: null, runtimeMs: Date.now() - attachStart, reason: 'capped' };
+}