badgr-cli 1.0.35 → 1.0.36

package/src/commands/comfyui.js

@@ -0,0 +1,318 @@
+/**
+ * badgr comfyui run workflow.json [--gpu RTX_4090] [--max-cost N] [--check-nodes node1,node2]
+ *
+ * Launches ComfyUI, health-checks /system_stats, and returns the URL.
+ * The workflow file is base64-encoded into COMFYUI_WORKFLOW_B64 so the container
+ * can queue it at startup.
+ */
+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 { formatCliError } from '../errors.js';
+
+const COMFYUI_IMAGE   = 'yanwk/comfyui-boot:latest';
+const HEALTH_PATH     = '/system_stats';
+const WAIT_TIMEOUT_MS = 10 * 60 * 1000; // 10 min — model downloads on first boot
+const MAX_WORKFLOW_B  = 1 * 1024 * 1024; // 1 MB workflow limit
+
+export function parseComfyuiArgs(args) {
+  const flags = {};
+  const positional = [];
+  let i = 0;
+  while (i < args.length) {
+    const a = args[i];
+    if (a === 'run') { i++; continue; } // optional subcommand
+    if (a === '--gpu')         { flags.gpu = args[++i]; i++; continue; }
+    if (a === '--max-cost')    { flags.maxCost = parseFloat(args[++i]); i++; continue; }
+    if (a === '--max-price')   { flags.maxPrice = parseFloat(args[++i]); i++; continue; }
+    if (a === '--tier')        { flags.tier = args[++i]; i++; continue; }
+    if (a === '--region')      { flags.region = args[++i]; i++; continue; }
+    if (a === '--no-wait')     { flags.noWait = true; i++; continue; }
+    if (a === '--check-nodes') { flags.checkNodes = args[++i]; i++; continue; }
+    if (a === '--persistent')  { flags.persistent = true; i++; continue; }
+    if (a === '--yes' || a === '-y') { flags.yes = true; i++; continue; }
+    if (a === '--env') {
+      const kv = args[++i]; i++;
+      if (!flags.env) flags.env = [];
+      flags.env.push(kv);
+      continue;
+    }
+    positional.push(args[i++]);
+  }
+  return { workflow: positional[0] || null, flags };
+}
+
+function parseEnvFlag(envList) {
+  const obj = {};
+  for (const kv of (envList || [])) {
+    const idx = kv.indexOf('=');
+    if (idx > 0) obj[kv.slice(0, idx)] = kv.slice(idx + 1);
+  }
+  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) {
+  const startMs  = Date.now();
+  const deadline = startMs + WAIT_TIMEOUT_MS;
+
+  while (Date.now() < deadline) {
+    try {
+      const dep = await callApi(`/deployments/${depId}`, {
+        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 };
+      }
+    } 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 }; }
+    } catch {}
+
+    const elapsed = Math.round((Date.now() - startMs) / 1000);
+    process.stdout.write(`\r  ${chalk.dim(stageLabel(elapsed) + ` (${elapsed}s)`)}   `);
+    await new Promise(r => setTimeout(r, 8000));
+  }
+
+  process.stdout.write('\n');
+  return { ready: false, timedOut: true, depFailed: false };
+}
+
+async function validateComfyNodes(endpointUrl, nodeList, chalk) {
+  const nodes = nodeList.split(',').map(n => n.trim()).filter(Boolean);
+  if (!nodes.length) return;
+  const objectInfoUrl = endpointUrl.replace(/\/v1\/?$/, '') + '/object_info';
+  console.log(chalk.dim(`\n  Checking custom nodes via ${objectInfoUrl}…`));
+  try {
+    const res = await fetch(objectInfoUrl, { signal: AbortSignal.timeout(15_000) });
+    if (!res.ok) { console.log(chalk.yellow(`  ⚠ Could not verify nodes (HTTP ${res.status})`)); return; }
+    const available = await res.json();
+    const found   = nodes.filter(n => Object.prototype.hasOwnProperty.call(available, n));
+    const missing = nodes.filter(n => !Object.prototype.hasOwnProperty.call(available, n));
+    if (found.length)   console.log(chalk.green(`  ✓ Nodes confirmed: ${found.join(', ')}`));
+    if (missing.length) {
+      console.log(chalk.yellow(`  ⚠ Nodes not found: ${missing.join(', ')}`));
+      console.log(chalk.dim('    These may not be installed in this image.'));
+    }
+  } catch (err) {
+    console.log(chalk.yellow(`  ⚠ Node check failed: ${err.message}`));
+  }
+}
+
+export async function comfyuiCommand(config, args, chalk) {
+  const { workflow, flags } = parseComfyuiArgs(args);
+
+  if (!workflow) {
+    console.error(chalk.red('\n  Usage: badgr comfyui run workflow.json\n'));
+    console.error(chalk.dim('  Launches ComfyUI, queues your workflow, and returns the URL.\n'));
+    process.exitCode = 1;
+    return;
+  }
+
+  requireApiKey(config);
+
+  if (!flags.maxCost && !flags.persistent) {
+    console.error(chalk.red('\n  ✗ ComfyUI endpoints bill continuously. Specify a spending limit:\n'));
+    console.error(chalk.dim('    --max-cost 5           auto-stop when $5 is reached'));
+    console.error(chalk.dim('    --persistent           run until you stop it manually\n'));
+    console.error(chalk.dim('  Example:'));
+    console.error(chalk.dim(`    badgr comfyui run ${workflow} --max-cost 10\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!existsSync(workflow)) {
+    console.error(chalk.red(`\n  ✗ Workflow file not found: ${workflow}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  let workflowRaw;
+  let workflowJson;
+  try {
+    workflowRaw  = readFileSync(workflow, 'utf8');
+    workflowJson = JSON.parse(workflowRaw);
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ Could not read ${workflow}: ${err.message}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (Buffer.byteLength(workflowRaw) > MAX_WORKFLOW_B) {
+    console.error(chalk.red(`\n  ✗ Workflow file exceeds 1 MB (${(Buffer.byteLength(workflowRaw) / 1024).toFixed(0)} KB).\n`));
+    console.error(chalk.dim('  Split your workflow into smaller segments.\n'));
+    process.exitCode = 1;
+    return;
+  }
+
+  const nodeCount   = Object.keys(workflowJson).length;
+  const workflowB64 = Buffer.from(workflowRaw).toString('base64');
+
+  const gpu           = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : 'AUTO';
+  const effectiveTier = normalizeTier(flags.tier);
+  const envObj        = { ...parseEnvFlag(flags.env), COMFYUI_WORKFLOW_B64: workflowB64 };
+
+  console.log(chalk.bold('\n🎨 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}`);
+  if (flags.maxCost) {
+    console.log(`  ${chalk.bold('Max cost:')} $${flags.maxCost.toFixed(2)} (auto-stop)`);
+  } else {
+    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) {
+    try {
+      const existing = await listDeployments(config);
+      const ACTIVE = new Set(['running', 'provisioning', 'starting', 'queued']);
+      const dup = (existing.deployments ?? []).find(d =>
+        ACTIVE.has(d.status) && d.workload_type === 'endpoint' && d.image === COMFYUI_IMAGE
+      );
+      if (dup && !flags.yes) {
+        console.log(chalk.yellow('\n  ⚠ ComfyUI is already running:\n'));
+        console.log(`    ${chalk.cyan(dup.deployment_id)}  $${(dup.cost_per_hour || 0).toFixed(2)}/hr`);
+        if (dup.endpoint_url) console.log(`    URL: ${chalk.cyan(dup.endpoint_url)}`);
+        console.log();
+        console.log(chalk.dim('    Reuse:       Use the URL above'));
+        console.log(chalk.dim(`    Stop first:  badgr down ${dup.deployment_id}`));
+        console.log(chalk.dim('    Launch new:  add --yes to this command\n'));
+        process.exitCode = 1;
+        return;
+      }
+    } catch {}
+  }
+
+  function buildBody(tierOverride) {
+    return {
+      image:              COMFYUI_IMAGE,
+      gpu,
+      gpu_count:          1,
+      ...(flags.region ? { region: flags.region.toUpperCase() } : {}),
+      max_price_per_hour: flags.maxPrice,
+      tier:               tierOverride || effectiveTier,
+      env:                envObj,
+      ...(flags.maxCost ? { max_cost_usd: flags.maxCost } : {}),
+    };
+  }
+
+  let dep;
+  try {
+    dep = await callWithFallback(
+      '/serve',
+      { apiKey: config.apiKey, baseUrl: config.baseUrl },
+      (tierOverride) => buildBody(tierOverride),
+      effectiveTier,
+      chalk,
+      { thing: 'ComfyUI endpoint', cmd: 'badgr comfyui run' },
+    );
+  } catch (err) {
+    if (err.isPaymentRequired) { console.error(chalk.yellow(err.message)); process.exitCode = 1; return; }
+    console.error(err.message);
+    process.exitCode = 1;
+    return;
+  }
+
+  addDeployment({
+    id:            dep.deployment_id,
+    type:          'endpoint',
+    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 comfyui run',
+    deploymentId:  dep.deployment_id,
+    gpu:           dep.gpu_type,
+    providerRoute: dep.provider ?? null,
+    tier:          dep.tier ?? null,
+    status:        dep.status,
+    createdAt:     new Date().toISOString(),
+  });
+
+  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`));
+    updateReceipt(rcptId, { status: 'no_endpoint_url' });
+    process.exitCode = 1;
+    return;
+  }
+
+  let endpointReady = false;
+  if (flags.noWait) {
+    console.log(chalk.yellow('\n  Skipped health check (--no-wait)\n'));
+  } else {
+    const result = await waitForComfyUI(endpointUrl, dep.deployment_id, config, chalk);
+    process.stdout.write('\n');
+
+    if (result.depFailed) {
+      console.error(formatCliError('HEALTH_CHECK_DEPLOY_FAILED', {
+        deploymentId: dep.deployment_id,
+        failReason:   result.failReason,
+      }, chalk));
+      updateReceipt(rcptId, { status: 'failed', failReason: result.failReason });
+      process.exitCode = 1;
+      return;
+    }
+
+    endpointReady = result.ready;
+    if (!endpointReady) updateReceipt(rcptId, { status: 'health_check_timeout' });
+  }
+
+  if (flags.checkNodes && endpointReady) {
+    await validateComfyNodes(endpointUrl, flags.checkNodes, chalk);
+  }
+
+  updateReceipt(rcptId, {
+    status:    endpointReady ? 'ready' : 'starting',
+    endpointUrl,
+    updatedAt: new Date().toISOString(),
+  });
+
+  if (endpointReady) {
+    console.log(chalk.green('\n  ✓ ComfyUI ready\n'));
+  } else {
+    console.log(chalk.yellow('\n  ⏳ ComfyUI still starting.\n'));
+    console.log(`  ${chalk.bold('Continue watching:')}  ${chalk.dim(`badgr logs ${dep.deployment_id}`)}`);
+    console.log(`  ${chalk.bold('Stop billing now:')}   ${chalk.dim(`badgr down ${dep.deployment_id}`)}`);
+    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/down.js

@@ -1,12 +1,21 @@
 import { requireApiKey } from '../config.js';
 import { findDeployment, removeDeployment, addReceipt, generateReceiptId } from '../store.js';
-import { terminateDeployment } from '../api.js';
+import { terminateDeployment, listDeployments } from '../api.js';
 
 export async function downCommand(config, args, chalk) {
+  const hasAll = args.includes('--all');
+  const hasYes = args.includes('--yes') || args.includes('-y');
+
+  if (hasAll) {
+    return _downAll(config, chalk, hasYes);
+  }
+
   const idOrName = args.find(a => !a.startsWith('--'));
 
   if (!idOrName) {
     console.error(chalk.red('Usage: badgr down <deployment-id|name>'));
+    console.error(chalk.dim('       badgr down --all          stop everything'));
+    console.error(chalk.dim('       badgr down --all --yes    stop everything without confirmation'));
     return;
   }
 
@@ -55,3 +64,80 @@ export async function downCommand(config, args, chalk) {
   if (finalCost > 0) console.log(`  ${chalk.bold('Final cost:')} $${finalCost.toFixed(4)}`);
   console.log(`  ${chalk.bold('Receipt:')}    ${chalk.dim(rcptId)}\n`);
 }
+
+async function _downAll(config, chalk, skipConfirm) {
+  requireApiKey(config);
+
+  let result;
+  try {
+    result = await listDeployments(config);
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ Could not fetch deployments: ${err.message}\n`));
+    return;
+  }
+
+  const ACTIVE = new Set(['running', 'provisioning', 'starting', 'queued']);
+  const active = (result.deployments ?? []).filter(d => ACTIVE.has(d.status));
+
+  if (active.length === 0) {
+    console.log(chalk.dim('\n  Nothing running. Billing is $0/hr.\n'));
+    return;
+  }
+
+  const totalRate = active.reduce((s, d) => s + (d.cost_per_hour || 0), 0);
+  console.log(chalk.bold(`\n  ${active.length} deployment(s) running — $${totalRate.toFixed(2)}/hr\n`));
+  for (const d of active) {
+    const rate = (d.cost_per_hour || 0).toFixed(2);
+    const label = d.model || d.image || d.workload_type || '';
+    console.log(`    ${chalk.cyan(d.deployment_id)}  ${d.gpu_type || ''}  $${rate}/hr  ${chalk.dim(label)}`);
+  }
+  console.log();
+
+  if (!skipConfirm) {
+    const { createInterface } = await import('readline');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise(resolve => {
+      rl.question(chalk.yellow(`  Stop all ${active.length} deployment(s)? [y/N] `), resolve);
+    });
+    rl.close();
+    if (!answer.trim().match(/^y$/i)) {
+      console.log(chalk.dim('\n  Aborted.\n'));
+      return;
+    }
+    console.log();
+  }
+
+  let stoppedCount = 0;
+  let totalCost = 0;
+
+  for (const dep of active) {
+    process.stdout.write(chalk.dim(`  Stopping ${dep.deployment_id}...`));
+    try {
+      const stopped = await terminateDeployment(config, dep.deployment_id);
+      const stoppedAt = stopped.stopped_at ?? (Date.now() / 1000);
+      const startedAt = stopped.started_at ?? stoppedAt;
+      const cost      = (stopped.cost_per_hour || 0) * (stoppedAt - startedAt) / 3600;
+      totalCost += cost;
+      process.stdout.write(chalk.green(' done\n'));
+      stoppedCount++;
+      removeDeployment(dep.deployment_id);
+      const rcptId = generateReceiptId();
+      addReceipt({
+        receiptId:      rcptId,
+        action:         'badgr down --all',
+        deploymentId:   dep.deployment_id,
+        gpu:            dep.gpu_type,
+        runtimeSeconds: Math.round(stoppedAt - startedAt),
+        finalCost:      cost,
+        status:         'terminated',
+        createdAt:      new Date().toISOString(),
+      });
+    } catch (err) {
+      process.stdout.write(chalk.red(` ✗ ${err.message}\n`));
+    }
+  }
+
+  console.log(chalk.green(`\n✓ Stopped ${stoppedCount}/${active.length} deployment(s)`));
+  if (totalCost > 0) console.log(`  Estimated total: $${totalCost.toFixed(4)}`);
+  console.log(chalk.green('  Billing ended\n'));
+}

package/src/commands/embed.js

@@ -0,0 +1,229 @@
+/**
+ * badgr embed <model> <input-url-or-file> [--max-cost N]
+ *
+ * Generates text embeddings on GPU using vLLM's embed task.
+ * Accepts a public URL, S3/GCS URI, or a local text file under 10 MB.
+ * Embeddings are written to stdout by the container and appear in logs.
+ *
+ * Examples:
+ *   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
+ */
+import { readFileSync, existsSync, statSync } from 'fs';
+import { requireApiKey } from '../config.js';
+import { addReceipt, generateReceiptId } from '../store.js';
+import { normalizeTier, callWithFallback } from '../fallback.js';
+import { monitorBatchJob, fmtRuntime } from '../batch.js';
+
+const EMBED_IMAGE          = 'vllm/vllm-openai:latest';
+const DEFAULT_EMBED_MODEL  = 'BAAI/bge-large-en-v1.5';
+const DEFAULT_MAX_RUNTIME_MIN = 30;
+const MAX_INLINE_B = 10 * 1024 * 1024; // 10 MB inline limit
+
+export function parseEmbedArgs(args) {
+  const flags = {};
+  const positional = [];
+  let i = 0;
+  while (i < args.length) {
+    const a = args[i];
+    if (a === '--model')       { flags.model = args[++i]; i++; continue; }
+    if (a === '--gpu')         { flags.gpu = args[++i]; i++; continue; }
+    if (a === '--max-cost')    { flags.maxCost = parseFloat(args[++i]); i++; continue; }
+    if (a === '--max-price')   { flags.maxPrice = parseFloat(args[++i]); i++; continue; }
+    if (a === '--max-runtime') { flags.maxRuntime = parseFloat(args[++i]); i++; continue; }
+    if (a === '--tier')        { flags.tier = args[++i]; i++; continue; }
+    if (a === '--region')      { flags.region = args[++i]; i++; continue; }
+    if (a === '--batch-size')  { flags.batchSize = parseInt(args[++i], 10); i++; continue; }
+    if (a === '--detach')      { flags.detach = true; i++; continue; }
+    if (a === '--env') {
+      const kv = args[++i]; i++;
+      if (!flags.env) flags.env = [];
+      flags.env.push(kv);
+      continue;
+    }
+    positional.push(args[i++]);
+  }
+  // positional: [model, input] or [input] (model falls back to default or --model flag)
+  const model = positional.length >= 2 ? positional[0] : (flags.model || DEFAULT_EMBED_MODEL);
+  const input = positional.length >= 2 ? positional[1] : positional[0] || null;
+  return { model, input, flags };
+}
+
+function parseEnvFlag(envList) {
+  const obj = {};
+  for (const kv of (envList || [])) {
+    const idx = kv.indexOf('=');
+    if (idx > 0) obj[kv.slice(0, idx)] = kv.slice(idx + 1);
+  }
+  return obj;
+}
+
+function isUrl(s) {
+  return /^(https?|s3|gs|hf):\/\//i.test(s);
+}
+
+/**
+ * Resolve input to { inputUrl, inputB64, inputLabel }.
+ */
+export function resolveEmbedInput(input) {
+  if (isUrl(input)) {
+    return { inputUrl: input, inputB64: null, inputLabel: input };
+  }
+  if (!existsSync(input)) {
+    return { error: `File not found: ${input}` };
+  }
+  const size = statSync(input).size;
+  if (size > MAX_INLINE_B) {
+    return {
+      error: `File too large for inline transfer (${(size / 1024 / 1024).toFixed(1)} MB > 10 MB limit).\n` +
+             '  Upload to S3 or a public URL and pass the URL instead.',
+    };
+  }
+  const inputB64 = readFileSync(input).toString('base64');
+  return { inputUrl: null, inputB64, inputLabel: input };
+}
+
+export async function embedCommand(config, args, chalk) {
+  const { model, input, flags } = parseEmbedArgs(args);
+
+  if (!input) {
+    console.error(chalk.red('\n  Usage: badgr embed <model> <input-url-or-file>\n'));
+    console.error(chalk.dim('  Examples:'));
+    console.error(chalk.dim('    badgr embed BAAI/bge-large-en-v1.5 documents.txt --max-cost 2'));
+    console.error(chalk.dim('    badgr embed BAAI/bge-large-en-v1.5 s3://bucket/corpus.jsonl'));
+    console.error(chalk.dim('    badgr embed documents.txt  (uses default model)\n'));
+    process.exitCode = 1;
+    return;
+  }
+
+  requireApiKey(config);
+
+  const resolved = resolveEmbedInput(input);
+  if (resolved.error) {
+    console.error(chalk.red(`\n  ✗ ${resolved.error}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  const gpu           = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : 'AUTO';
+  const effectiveTier = normalizeTier(flags.tier);
+  const maxRuntimeMin = flags.maxRuntime ?? DEFAULT_MAX_RUNTIME_MIN;
+  const maxRuntimeMs  = maxRuntimeMin * 60 * 1000;
+  const maxCost       = flags.maxCost ?? null;
+
+  const envObj = {
+    ...parseEnvFlag(flags.env),
+    EMBED_MODEL:   model,
+    VLLM_TASK:     'embed',
+    ...(resolved.inputUrl  ? { EMBED_INPUT_URL: resolved.inputUrl } : {}),
+    ...(resolved.inputB64  ? { EMBED_INPUT_B64: resolved.inputB64 } : {}),
+    ...(flags.batchSize    ? { EMBED_BATCH_SIZE: String(flags.batchSize) } : {}),
+  };
+
+  console.log(chalk.bold('\n📐 Embeddings\n'));
+  console.log(`  ${chalk.bold('Input:')}       ${resolved.inputLabel}`);
+  console.log(`  ${chalk.bold('Model:')}       ${model}`);
+  console.log(`  ${chalk.bold('Image:')}       ${EMBED_IMAGE}`);
+  console.log(`  ${chalk.bold('GPU:')}         ${gpu === 'AUTO' ? chalk.dim('auto (8+ GB VRAM)') : gpu}`);
+  console.log(`  ${chalk.bold('Max runtime:')} ${maxRuntimeMin}min`);
+  if (maxCost) console.log(`  ${chalk.bold('Max cost:')}    $${maxCost.toFixed(2)}`);
+  console.log();
+  process.stdout.write(chalk.dim('  Finding suitable capacity...\n'));
+
+  function buildBody(tierOverride) {
+    return {
+      image: EMBED_IMAGE,
+      command: ['sh', '-c', [
+        resolved.inputB64
+          ? 'echo "$EMBED_INPUT_B64" | base64 -d > /tmp/embed_input.txt && export INPUT_PATH=/tmp/embed_input.txt'
+          : 'export INPUT_PATH="$EMBED_INPUT_URL"',
+        'python3 -c "' +
+          'import json, sys; ' +
+          'from vllm import LLM; ' +
+          'llm = LLM(model=\\\"$EMBED_MODEL\\\", task=\\\"embed\\\"); ' +
+          'lines = open(\\\"$INPUT_PATH\\\").read().splitlines(); ' +
+          'outputs = llm.embed(lines); ' +
+          '[print(json.dumps({\\\"text\\\": l, \\\"embedding\\\": o.outputs.embedding})) for l, o in zip(lines, outputs)]' +
+          '"',
+      ].join(' && ')],
+      gpu,
+      gpu_count:           1,
+      ...(flags.region ? { region: flags.region.toUpperCase() } : {}),
+      max_price_per_hour:  flags.maxPrice,
+      tier:                tierOverride || effectiveTier,
+      env:                 envObj,
+      max_runtime_seconds: maxRuntimeMin * 60,
+      ...(maxCost ? { max_cost_usd: maxCost } : {}),
+    };
+  }
+
+  let dep;
+  try {
+    dep = await callWithFallback(
+      '/run',
+      { apiKey: config.apiKey, baseUrl: config.baseUrl },
+      (tierOverride) => buildBody(tierOverride),
+      effectiveTier,
+      chalk,
+      { thing: 'embeddings job', cmd: 'badgr embed' },
+    );
+  } catch (err) {
+    if (err.isPaymentRequired) { console.error(chalk.yellow(err.message)); process.exitCode = 1; return; }
+    console.error(err.message);
+    process.exitCode = 1;
+    return;
+  }
+
+  const rcptId = dep.receipt_id || generateReceiptId();
+  addReceipt({
+    receiptId:     rcptId,
+    action:        'badgr embed',
+    deploymentId:  dep.deployment_id,
+    gpu:           dep.gpu_type,
+    providerRoute: dep.provider ?? null,
+    tier:          dep.tier ?? null,
+    maxCost,
+    maxRuntime:    maxRuntimeMin,
+    status:        dep.status,
+    createdAt:     new Date().toISOString(),
+  });
+
+  const rate = dep.cost_per_hour || 0;
+  console.log(chalk.dim('  Capacity found.\n'));
+  console.log(chalk.bold(`  Job ID:    ${chalk.cyan(dep.deployment_id)}`));
+  console.log(`  ${chalk.bold('GPU:')}      ${dep.gpu_type} × ${dep.gpu_count}`);
+  if (rate > 0) console.log(`  ${chalk.bold('Rate:')}     $${rate.toFixed(2)}/hr`);
+  console.log(`  ${chalk.bold('Receipt:')}  ${chalk.dim(rcptId)}`);
+
+  if (flags.detach) {
+    console.log(`\n  ${chalk.bold('Logs:')}  ${chalk.dim(`badgr logs ${dep.deployment_id}`)}`);
+    console.log(chalk.dim(`\n  Detached. View embeddings: badgr logs ${dep.deployment_id}\n`));
+    return;
+  }
+
+  const result = await monitorBatchJob(config, dep.deployment_id, rcptId, {
+    chalk,
+    maxRuntimeMs,
+    maxCost,
+    ratePerHour: rate,
+  });
+
+  console.log();
+  const finalCost = rate * (result.runtimeMs / 3_600_000);
+  console.log(`  ${chalk.bold('Runtime:')}  ${fmtRuntime(result.runtimeMs)}`);
+  if (rate > 0) console.log(`  ${chalk.bold('Cost:')}     $${finalCost.toFixed(4)}`);
+  console.log(`  ${chalk.bold('Receipt:')}  ${chalk.dim(rcptId)}`);
+
+  if (result.reason === 'complete' &&
+      (result.status === 'completed' || result.status === 'succeeded') &&
+      (result.exitCode === 0 || result.exitCode === null)) {
+    console.log(chalk.green('\n  ✓ Embeddings complete\n'));
+    console.log(chalk.dim('  Embeddings (JSONL) appear above in the log output.'));
+    console.log(chalk.dim(`  Full logs: badgr logs ${dep.deployment_id}\n`));
+  } else if (result.reason !== 'interrupted' &&
+             (result.status === 'failed' || (result.exitCode !== null && result.exitCode !== 0))) {
+    console.error(chalk.red('\n  ✗ Embeddings job failed\n'));
+    console.error(chalk.dim(`  Logs: badgr logs ${dep.deployment_id}\n`));
+    process.exitCode = result.exitCode ?? 1;
+  }
+}