badgr-cli 1.0.37 → 1.0.39

package/README.md

@@ -275,7 +275,7 @@ Additional GPU types may be routable depending on current capacity — check wit
 
 Pricing is confirmed before provisioning. Use `--dry-run` to see pricing before committing.
 
-Full GPU support details: see [GPU_SUPPORT.md](../../GPU_SUPPORT.md) in the repo root.
+Full GPU support details: see [NOTES.md](../../NOTES.md#gpu-support) in the repo root.
 
 ---
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "badgr-cli",
-  "version": "1.0.37",
-  "description": "Badgr, run or serve GPU workloads from one command",
+  "version": "1.0.39",
+  "description": "DEPRECATED: Use badgr-agent CLI instead. Badgr, run or serve GPU workloads from one command",
   "type": "module",
   "bin": {
     "badgr": "src/badgr.js"
@@ -12,23 +12,21 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@inquirer/prompts": "^8.5.2",
-    "chalk": "^5.3.0"
+    "badgr-agent": "1.0.0"
   },
   "devDependencies": {
     "vitest": "^4.1.8"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.10.0"
   },
   "keywords": [
     "gpu",
     "cli",
     "ai",
     "compute",
-    "modal",
     "gateway",
     "openai"
   ],
-  "license": "MIT"
+  "license": "Apache-2.0"
 }

package/src/badgr.js

@@ -17,6 +17,9 @@ import { comfyuiCommand }    from './commands/comfyui.js';
 import { trainCommand }      from './commands/train.js';
 import { transcribeCommand } from './commands/transcribe.js';
 import { embedCommand }      from './commands/embed.js';
+import { templateCommand }   from './commands/template.js';
+import { workloadCommand }   from './commands/workload.js';
+import { workspaceCommand }  from './commands/workspace.js';
 
 const HELP = `
 ${chalk.bold('badgr')} — run or serve GPU workloads from one command
@@ -32,12 +35,19 @@ ${chalk.bold('COMMANDS')}
   ${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
   ${chalk.cyan('badgr billing')}             Show balance and add funds
+  ${chalk.cyan('badgr workload list')}       List saved workloads
+  ${chalk.cyan('badgr workload run <name>')} Rerun a saved workload
+  ${chalk.cyan('badgr workspace list')}      List workspace trackers (job history + cost per named context)
+  ${chalk.cyan('badgr workspace create')}    Create a workspace tracker (link jobs to a named storage path)
 
 ${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.cyan('badgr serve template <name>')}         Launch an endpoint template (vllm, invokeai, comfyui, …)
+  ${chalk.cyan('badgr run   template <name>')}         Launch a job template (axolotl, unsloth)
+  ${chalk.cyan('badgr template list')}                 Browse all pre-built templates
 
 ${chalk.bold('EXAMPLES')}
   ${chalk.dim('# Verify the stack works end-to-end:')}
@@ -46,6 +56,12 @@ ${chalk.bold('EXAMPLES')}
   ${chalk.dim('# Serve a model (OpenAI-compatible):')}
   badgr serve meta-llama/Llama-3.1-8B-Instruct --max-cost 10
 
+  ${chalk.dim('# Serve a Hugging Face GGUF file via llama.cpp:')}
+  badgr serve --runtime llama.cpp \\
+    --hf-repo org/model-repo \\
+    --hf-file model.gguf \\
+    --max-cost 10
+
   ${chalk.dim('# Launch ComfyUI with a workflow:')}
   badgr comfyui run workflow.json --max-cost 5
 
@@ -94,7 +110,10 @@ ${chalk.bold('badgr serve OPTIONS')}
   --count <n>            Number of GPUs (default: 1)
   --region US|EU|AU      Region preference
   --max-price <$/hr>     Hard spend cap per GPU-hour
-  --health-path <path>   Readiness path to poll (auto-detected for comfyui → /system_stats)
+  --runtime llama.cpp    Serve a HF GGUF file via llama.cpp instead of vLLM
+  --hf-repo <repo>       Hugging Face repo (use with --runtime llama.cpp), e.g. org/model-repo
+  --hf-file <file>       GGUF filename within that repo, e.g. model.gguf
+  --health-path <path>   Readiness path to poll (auto-detected: comfyui → /system_stats, llama.cpp → /health)
   --no-wait              Skip endpoint health check
 
 ${chalk.bold('AFTER SERVING')}
@@ -133,6 +152,9 @@ async function main() {
     case 'train':     return trainCommand(config, rest, chalk);
     case 'transcribe': return transcribeCommand(config, rest, chalk);
     case 'embed':     return embedCommand(config, rest, chalk);
+    case 'template':  return templateCommand(config, rest, chalk);
+    case 'workload':   return workloadCommand(config, rest, chalk);
+    case 'workspace':  return workspaceCommand(config, rest, chalk);
     // legacy aliases kept for compatibility
     case 'up':        return upCommand(config, rest, chalk);
     case 'config': {

package/src/catalog.js

@@ -0,0 +1,479 @@
+/**
+ * Template catalog — shared by template.js, serve.js, and run.js.
+ * No imports from other badgr commands to avoid circular dependencies.
+ */
+
+export const TEMPLATES = [
+  {
+    name:        'comfyui',
+    title:       'ComfyUI',
+    description: 'Stable Diffusion image generation with ComfyUI node editor',
+    type:        'endpoint',
+    image:       process.env.COMFYUI_IMAGE || 'yanwk/comfyui-boot:cu126-megapak',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    port:        8188,
+    health_path: '/system_stats',
+    min_vram_gb: 16,
+    env:         {},
+    notes: [
+      'Access the ComfyUI UI at the returned endpoint URL.',
+      'Tip: use `badgr comfyui run workflow.json` to also queue a workflow at boot.',
+    ],
+  },
+  {
+    name:        'axolotl',
+    title:       'Axolotl Fine-Tuning',
+    description: 'LLM LoRA/QLoRA fine-tuning with the Axolotl training framework',
+    type:        'job',
+    image:       'axolotlai/axolotl-cloud-uv:main-latest',
+    gpu:         'A100',
+    gpu_count:   1,
+    min_vram_gb: 40,
+    env: {
+      HF_TOKEN:      '<your-hf-token>',
+      WANDB_API_KEY: '<optional>',
+      HF_HUB_CACHE:  '/workspace/hf-cache',
+    },
+    notes: [
+      'Preferred: `badgr train config.yaml` auto-detects Axolotl configs.',
+      'Pass HF_TOKEN via --env or BADGR_HF_TOKEN env var.',
+    ],
+  },
+  {
+    name:        'unsloth',
+    title:       'Unsloth Fine-Tuning',
+    description: 'Fast LoRA/QLoRA fine-tuning — 2x faster, 60% less VRAM than baseline',
+    type:        'job',
+    image:       'unslothai/unsloth:latest',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    min_vram_gb: 16,
+    env: {
+      HF_TOKEN: '<your-hf-token>',
+    },
+    notes: [
+      'Use `badgr train config.yaml --framework unsloth` for config-driven runs.',
+      'Unsloth detects the GPU environment automatically.',
+    ],
+  },
+  {
+    name:        'vllm',
+    title:       'vLLM OpenAI Server',
+    description: 'OpenAI-compatible LLM inference endpoint powered by vLLM',
+    type:        'endpoint',
+    image:       'vllm/vllm-openai:latest',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    port:        8000,
+    health_path: '/v1/models',
+    min_vram_gb: 24,
+    env: {
+      MODEL:                'meta-llama/Llama-3.1-8B-Instruct',
+      HF_TOKEN:             '<for-gated-models>',
+      MAX_MODEL_LEN:        '8192',
+      TENSOR_PARALLEL_SIZE: '1',
+    },
+    command: [
+      'python', '-m', 'vllm.entrypoints.openai.api_server',
+      '--model', '${MODEL}',
+      '--host', '0.0.0.0',
+      '--port', '8000',
+      '--tensor-parallel-size', '${TENSOR_PARALLEL_SIZE}',
+    ],
+    notes: [
+      'Override MODEL with any HuggingFace model ID via --env MODEL=<id>.',
+      'For multi-GPU: increase gpu_count and TENSOR_PARALLEL_SIZE to match.',
+      'HF_TOKEN required for gated models (Llama, Gemma, Mistral).',
+      'OpenAI client: OpenAI(base_url="<endpoint>/v1", api_key="<key>")',
+    ],
+  },
+  {
+    name:        'llama-cpp',
+    title:       'llama.cpp Server',
+    description: 'Fast quantised (GGUF) model inference via llama.cpp HTTP server',
+    type:        'endpoint',
+    image:       'michaelmanleyx/llama-cpp:server-cuda',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    port:        8080,
+    health_path: '/health',
+    min_vram_gb: 8,
+    env: {
+      LLAMA_ARG_HF_REPO: 'bartowski/Meta-Llama-3.1-8B-Instruct-GGUF',
+      LLAMA_ARG_HF_FILE: 'Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf',
+    },
+    notes: [
+      'Preferred: `badgr serve --runtime llama.cpp --hf-repo <repo> --hf-file <file>`.',
+      'Override LLAMA_ARG_HF_REPO and LLAMA_ARG_HF_FILE via --env.',
+      'Supports any GGUF from HuggingFace Hub.',
+    ],
+  },
+  {
+    name:        'invokeai',
+    title:       'InvokeAI',
+    description: 'Professional Stable Diffusion image generation and editing with InvokeAI',
+    type:        'endpoint',
+    image:       'ghcr.io/invoke-ai/invokeai:latest',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    port:        9090,
+    health_path: '/api/v1/app/version',
+    min_vram_gb: 16,
+    env: {
+      INVOKEAI_ROOT: '/workspace/invokeai',
+      PUBLIC_KEY:    '<optional-ssh-public-key>',
+    },
+    notes: [
+      'First boot downloads models — allow 5–10 min before the UI is ready.',
+      'Set PUBLIC_KEY to inject an SSH key for SCP file transfers.',
+      'Models and outputs persist under INVOKEAI_ROOT.',
+    ],
+  },
+  {
+    name:        'kohya-ss',
+    title:       'Kohya SS Training',
+    description: 'Stable Diffusion LoRA/DreamBooth/fine-tuning via Kohya SS web GUI',
+    type:        'endpoint',
+    image:       'bmaltais/kohya-ss-gui:latest',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    port:        7860,
+    health_path: '/',
+    min_vram_gb: 8,
+    env: {
+      HUGGINGFACE_TOKEN: '<optional>',
+    },
+    notes: [
+      'Kohya SS GUI is available at the returned endpoint URL (port 7860).',
+      'For headless LoRA training, use `badgr train config.yaml` instead.',
+    ],
+  },
+  {
+    name:        'text-gen-webui',
+    title:       'Text Generation WebUI',
+    description: 'Oobabooga text-generation-webui — feature-rich LLM front-end for many backends',
+    type:        'endpoint',
+    image:       'atinoda/text-generation-webui:default-nightly',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    port:        7860,
+    health_path: '/',
+    min_vram_gb: 16,
+    env: {
+      HF_TOKEN: '<for-gated-models>',
+    },
+    notes: [
+      'Load models from the web UI or pre-set via command args inside the container.',
+      'Supports llama.cpp, ExLlamaV2, AutoGPTQ, transformers, and more.',
+    ],
+  },
+  {
+    name:        'sglang',
+    title:       'SGLang Server',
+    description: 'High-throughput LLM serving optimised for structured generation (SGLang)',
+    type:        'endpoint',
+    image:       'lmsysorg/sglang:latest',
+    gpu:         'A100',
+    gpu_count:   1,
+    port:        30000,
+    health_path: '/health',
+    min_vram_gb: 40,
+    env: {
+      MODEL_PATH: 'meta-llama/Llama-3.1-8B-Instruct',
+      HF_TOKEN:   '<for-gated-models>',
+      TP_SIZE:    '1',
+    },
+    command: [
+      'python', '-m', 'sglang.launch_server',
+      '--model-path', '${MODEL_PATH}',
+      '--host', '0.0.0.0',
+      '--port', '30000',
+      '--tp', '${TP_SIZE}',
+    ],
+    notes: [
+      'Optimised for structured output (JSON schema, regex) and RadixAttention.',
+      'OpenAI-compatible API on port 30000.',
+      'Increase TP_SIZE and gpu_count together for tensor parallelism.',
+      'HF_TOKEN required for gated models.',
+    ],
+  },
+  {
+    name:        'tgi',
+    title:       'Text Generation Inference (TGI)',
+    description: 'Hugging Face TGI — production-grade LLM inference with continuous batching',
+    type:        'endpoint',
+    image:       'ghcr.io/huggingface/text-generation-inference:latest',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    port:        80,
+    health_path: '/health',
+    min_vram_gb: 24,
+    env: {
+      MODEL_ID:         'meta-llama/Llama-3.1-8B-Instruct',
+      HF_TOKEN:         '<for-gated-models>',
+      MAX_INPUT_LENGTH: '4096',
+      MAX_TOTAL_TOKENS: '8192',
+      NUM_SHARD:        '1',
+    },
+    notes: [
+      'OpenAI-compatible API at /v1/chat/completions.',
+      'Set NUM_SHARD equal to gpu_count for sharded (tensor-parallel) inference.',
+      'HF_TOKEN required for Llama, Gemma, and other gated models.',
+    ],
+  },
+  {
+    name:        'auto1111',
+    title:       'AUTOMATIC1111',
+    description: 'Stable Diffusion web UI — the largest SD ecosystem with ControlNet, LoRA, img2img, inpainting, and upscaling',
+    type:        'endpoint',
+    image:       'aidockorg/stable-diffusion-webui-cuda:latest',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    port:        7860,
+    health_path: '/',
+    min_vram_gb: 6,
+    env: {
+      WEBUI_FLAGS: '--xformers',
+    },
+    notes: [
+      'Web UI at the returned endpoint URL (port 7860).',
+      'Place model checkpoints under /opt/dl-ui/repositories/stable-diffusion-webui/models/Stable-diffusion/.',
+      'Override WEBUI_FLAGS to pass extra launch args (e.g. --medvram for lower VRAM).',
+    ],
+  },
+  {
+    name:        'forge',
+    title:       'Stable Diffusion WebUI Forge',
+    description: 'Optimised fork of A1111 with GPU memory improvements — runs models that OOM on standard A1111',
+    type:        'endpoint',
+    image:       'aidockorg/stable-diffusion-webui-forge-cuda:latest',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    port:        7860,
+    health_path: '/',
+    min_vram_gb: 4,
+    env: {
+      WEBUI_FLAGS: '--xformers',
+    },
+    notes: [
+      'Web UI at the returned endpoint URL (port 7860).',
+      'Forge uses less VRAM than A1111 for the same model — good for 8–12 GB cards.',
+      'Compatible with most A1111 extensions.',
+    ],
+  },
+  {
+    name:        'nerfstudio',
+    title:       'Nerfstudio',
+    description: 'NeRF and 3D Gaussian Splatting training and reconstruction from image captures',
+    type:        'job',
+    image:       'ghcr.io/nerfstudio-project/nerfstudio:latest',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    min_vram_gb: 16,
+    env: {
+      METHOD: 'nerfacto',
+    },
+    notes: [
+      'Mount your images to /workspace/data and your output dir to /workspace/outputs.',
+      'Override METHOD to switch between nerfacto, splatfacto, instant-ngp, etc.',
+      'Training a typical scene takes 15–45 min depending on method and image count.',
+    ],
+  },
+  {
+    name:        'openfold',
+    title:       'OpenFold',
+    description: 'Trainable, memory-efficient GPU-friendly PyTorch reproduction of AlphaFold 2 for protein structure prediction',
+    type:        'job',
+    image:       'nvidia/cuda:12.1.0-cudnn8-devel-ubuntu22.04',
+    gpu:         'A100',
+    gpu_count:   1,
+    min_vram_gb: 40,
+    env: {
+      OPENFOLD_REPO: 'https://github.com/aqlaboratory/openfold',
+    },
+    notes: [
+      'No pre-built public image exists — this uses a CUDA base; clone and install OpenFold at boot.',
+      'See https://github.com/aqlaboratory/openfold for full install steps.',
+      'Full inference on a single sequence: ~5–20 min on an A100.',
+    ],
+  },
+  {
+    name:        'blender-render',
+    title:       'Blender GPU Render',
+    description: 'Headless Blender GPU rendering via CUDA — render .blend files to image sequences or video',
+    type:        'job',
+    image:       'blenderkit/headless-blender:blender-4.4',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    min_vram_gb: 8,
+    env: {
+      BLEND_FILE: '/workspace/scene.blend',
+      FRAME_START: '1',
+      FRAME_END:   '250',
+    },
+    notes: [
+      'Mount your .blend file to /workspace/scene.blend.',
+      'Set FRAME_START and FRAME_END to the frame range to render.',
+      'Output frames are written to /workspace/output/ by default.',
+    ],
+  },
+  {
+    name:        'openmm',
+    title:       'OpenMM',
+    description: 'GPU-accelerated molecular dynamics simulation using the OpenMM toolkit',
+    type:        'job',
+    image:       'saladtechnologies/openmm:latest',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    min_vram_gb: 8,
+    env: {
+      SIMULATION_SCRIPT: '/workspace/simulate.py',
+    },
+    notes: [
+      'Mount your Python simulation script to /workspace/simulate.py.',
+      'OpenMM auto-selects CUDA platform when a GPU is present.',
+      'Typical MD simulation runs: minutes to hours depending on system size and steps.',
+    ],
+  },
+  {
+    name:        'gromacs',
+    title:       'GROMACS',
+    description: 'High-performance molecular dynamics package with GPU-accelerated bonded and non-bonded calculations',
+    type:        'job',
+    image:       'scientiflow/gromacs-gpu:2024.3',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    min_vram_gb: 8,
+    env: {
+      GMX_GPU_DD_COMMS:    'true',
+      GMX_GPU_PME_PP_COMMS: 'true',
+    },
+    notes: [
+      'Mount your .tpr input file and output directory to /workspace.',
+      'GROMACS auto-detects CUDA GPU — no extra flags needed.',
+      'For multi-GPU: increase gpu_count and pass -ntmpi / -ntomp flags via command override.',
+    ],
+  },
+  {
+    name:        'lammps',
+    title:       'LAMMPS',
+    description: 'Large-scale Atomic/Molecular Massively Parallel Simulator with GPU acceleration via Kokkos/CUDA',
+    type:        'job',
+    image:       'nvcr.io/hpc/lammps:release-29Sep2021',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    min_vram_gb: 8,
+    env: {
+      LAMMPS_INPUT: '/workspace/in.lammps',
+    },
+    notes: [
+      'Mount your LAMMPS input script to /workspace/in.lammps.',
+      'GPU acceleration uses the Kokkos or GPU package — enable via -pk gpu 1 in your input.',
+      'Simulation runtime scales with system size; use --max-runtime to cap spend.',
+    ],
+  },
+  {
+    name:        'diffusers',
+    title:       'Hugging Face Diffusers',
+    description: 'State-of-the-art diffusion model library for image, video, and audio generation',
+    type:        'job',
+    image:       'diffusers/diffusers-pytorch-cuda:latest',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    min_vram_gb: 16,
+    env: {
+      HF_TOKEN:   '<for-gated-models>',
+      MODEL_ID:   'stabilityai/stable-diffusion-xl-base-1.0',
+      SCRIPT:     '/workspace/run.py',
+    },
+    notes: [
+      'Mount your generation or training script to /workspace/run.py.',
+      'HF_TOKEN required for gated models.',
+      'Supports SDXL, FLUX, Stable Diffusion 3, ControlNet, IP-Adapter, and more.',
+    ],
+  },
+  {
+    name:        'torchtune',
+    title:       'torchtune',
+    description: 'PyTorch-native post-training library for LLM fine-tuning via config-driven YAML recipes',
+    type:        'job',
+    image:       'pytorch/pytorch:2.6.0-cuda12.4-cudnn9-devel',
+    gpu:         'A100',
+    gpu_count:   1,
+    min_vram_gb: 40,
+    env: {
+      HF_TOKEN: '<for-gated-models>',
+      RECIPE:   'lora_finetune_single_device',
+      CONFIG:   '/workspace/config.yaml',
+    },
+    notes: [
+      'Install torchtune at boot: pip install torchtune.',
+      'Mount your YAML recipe config to /workspace/config.yaml.',
+      'HF_TOKEN required for Llama and other gated base models.',
+      'Supports LoRA, QLoRA, DPO, full fine-tune, and quantisation-aware training.',
+    ],
+  },
+];
+
+export const TEMPLATE_MAP = Object.fromEntries(TEMPLATES.map(t => [t.name, t]));
+
+/**
+ * Build the args array passed to serveCommand / runCommand.
+ * Template defaults are applied first; CLI overrides win.
+ */
+export function buildTemplateFlags(template, overrides) {
+  const args = ['--image', template.image];
+
+  args.push('--gpu', overrides.gpu ?? template.gpu);
+
+  const count = overrides.count ?? template.gpu_count ?? 1;
+  if (count > 1) args.push('--count', String(count));
+
+  if (overrides.region)           args.push('--region', overrides.region);
+  if (overrides.maxCost != null)  args.push('--max-cost', String(overrides.maxCost));
+  if (overrides.maxPrice != null) args.push('--max-price', String(overrides.maxPrice));
+  if (overrides.tier)             args.push('--tier', overrides.tier);
+  if (overrides.name)             args.push('--name', overrides.name);
+  if (overrides.noWait)           args.push('--no-wait');
+  if (overrides.persistent)       args.push('--persistent');
+
+  if (template.type === 'endpoint' && template.health_path) {
+    args.push('--health-path', template.health_path);
+  }
+
+  // Merge env: template defaults first, user overrides win
+  const mergedEnv = { ...(template.env || {}), ...(overrides.env || {}) };
+  for (const [k, v] of Object.entries(mergedEnv)) {
+    if (!v.startsWith('<')) args.push('--env', `${k}=${v}`);
+  }
+
+  return args;
+}
+
+/** Parse the flags that follow `badgr serve template <name>` or `badgr run template <name>`. */
+export function parseTemplateOverrides(args) {
+  const overrides = { env: {} };
+  let i = 0;
+  while (i < args.length) {
+    const a = args[i];
+    if (a === '--gpu')         { overrides.gpu = args[++i]; i++; continue; }
+    if (a === '--count')       { overrides.count = parseInt(args[++i], 10); i++; continue; }
+    if (a === '--region')      { overrides.region = args[++i]; i++; continue; }
+    if (a === '--max-cost')    { overrides.maxCost = parseFloat(args[++i]); i++; continue; }
+    if (a === '--max-price')   { overrides.maxPrice = parseFloat(args[++i]); i++; continue; }
+    if (a === '--max-runtime') { overrides.maxRuntime = parseFloat(args[++i]); i++; continue; }
+    if (a === '--tier')        { overrides.tier = args[++i]; i++; continue; }
+    if (a === '--name')        { overrides.name = args[++i]; i++; continue; }
+    if (a === '--no-wait')     { overrides.noWait = true; i++; continue; }
+    if (a === '--persistent')  { overrides.persistent = true; i++; continue; }
+    if (a === '--env') {
+      const kv = args[++i]; i++;
+      const idx = kv.indexOf('=');
+      if (idx > 0) overrides.env[kv.slice(0, idx)] = kv.slice(idx + 1);
+      continue;
+    }
+    i++;
+  }
+  return overrides;
+}

package/src/commands/comfyui.js

@@ -12,7 +12,7 @@ import { addDeployment, addReceipt, updateReceipt, generateReceiptId } from '../
 import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
 import { formatCliError } from '../errors.js';
 
-const COMFYUI_IMAGE   = 'yanwk/comfyui-boot:latest';
+const COMFYUI_IMAGE   = process.env.COMFYUI_IMAGE || 'yanwk/comfyui-boot:cu126-megapak';
 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

package/src/commands/receipts.js

@@ -5,7 +5,8 @@ function fmtMs(ms) {
   return ms >= 1000 ? `${(ms / 1000).toFixed(1)}s` : `${ms}ms`;
 }
 
-function fmtRuntime(s) {
+export function fmtRuntime(s) {
+  if (s == null) return '—';
   if (s < 60) return `${s}s`;
   return `${Math.floor(s / 60)}m ${s % 60}s`;
 }