badgr-cli 1.0.37 → 1.0.38

package/package.json

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

package/src/badgr.js

@@ -17,6 +17,7 @@ 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';
 
 const HELP = `
 ${chalk.bold('badgr')} — run or serve GPU workloads from one command
@@ -38,6 +39,9 @@ ${chalk.bold('SHORTCUTS')}  ${chalk.dim('(wrappers around run / serve for common
   ${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 +50,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 +104,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 +146,7 @@ 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);
     // legacy aliases kept for compatibility
     case 'up':        return upCommand(config, rest, chalk);
     case 'config': {

package/src/catalog.js

@@ -0,0 +1,287 @@
+/**
+ * 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:       'yanwk/comfyui-boot:latest',
+    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.',
+    ],
+  },
+];
+
+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/run.js

@@ -3,6 +3,7 @@ import { callApi, terminateDeployment } from '../api.js';
 import { addReceipt, updateReceipt, generateReceiptId } from '../store.js';
 import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
 import { formatCliError } from '../errors.js';
+import { TEMPLATE_MAP, buildTemplateFlags, parseTemplateOverrides } from '../catalog.js';
 
 /**
  * badgr run python train.py                    # gpu=auto, attached
@@ -334,6 +335,28 @@ const _KNOWN_RUN_FLAGS = new Set([
 ]);
 
 export async function runCommand(config, args, chalk) {
+  // `badgr run template <name> [flags]` — expand template defaults then re-dispatch
+  if (args[0] === 'template') {
+    const name = args[1];
+    const t = name && TEMPLATE_MAP[name];
+    if (!t) {
+      console.error(chalk.red(`\n  Unknown template: ${name || '(none)'}\n`));
+      console.error(chalk.dim('  Run `badgr template list` to see available templates.'));
+      process.exitCode = 1;
+      return;
+    }
+    if (t.type !== 'job') {
+      console.error(chalk.red(`\n  "${name}" is an endpoint template — use: badgr serve template ${name}\n`));
+      process.exitCode = 1;
+      return;
+    }
+    const overrides = parseTemplateOverrides(args.slice(2));
+    const expandedArgs = buildTemplateFlags(t, overrides);
+    if (overrides.maxRuntime != null) expandedArgs.push('--max-runtime', String(overrides.maxRuntime));
+    console.log(chalk.dim(`  Template: ${t.title}  →  badgr run ${expandedArgs.join(' ')}\n`));
+    return runCommand(config, expandedArgs, chalk);
+  }
+
   const { flags, positional } = parseRunArgs(args);
 
   // Detect flags that ended up in the command because of broken shell line continuation

package/src/commands/serve.js

@@ -3,12 +3,16 @@ 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';
+import { TEMPLATE_MAP, buildTemplateFlags, parseTemplateOverrides } from '../catalog.js';
+
+const LLAMA_CPP_IMAGE = 'michaelmanleyx/llama-cpp:server-cuda';
 
 /**
  * badgr serve meta-llama/Llama-3.1-8B-Instruct
  * badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S
  * badgr serve BAAI/bge-large-en-v1.5 --task embed
  * badgr serve --image ghcr.io/my-org/diffusers-api:latest --gpu L40S --env MODEL_ID=flux
+ * badgr serve --runtime llama.cpp --hf-repo org/repo --hf-file model.gguf --max-cost 10
  *
  * GPU defaults to "AUTO" — backend infers from model size.
  */
@@ -35,6 +39,9 @@ export function parseServeArgs(args) {
         args[i] === '--no-expanded-search') { flags.noMarketplaceFallback = true; i++; continue; }
     if (args[i] === '--persistent')          { flags.persistent = true; i++; continue; }
     if (args[i] === '--yes' || args[i] === '-y') { flags.yes = true; i++; continue; }
+    if (args[i] === '--runtime')  { flags.runtime = args[++i]; i++; continue; }
+    if (args[i] === '--hf-repo') { flags.hfRepo = args[++i]; i++; continue; }
+    if (args[i] === '--hf-file') { flags.hfFile = args[++i]; i++; continue; }
     if (args[i] === '--env') {
       const kv = args[++i]; i++;
       if (!flags.env) flags.env = [];
@@ -73,12 +80,34 @@ function _inferServeProfile(modelName) {
   return                      { label: 'inference (70B+ model)',    vram: '80+ GB', gpus: ['H100', 'A100'] };
 }
 
+// Mirror of backend workload_profile.py infer_profile_from_gguf.
+// Accepts the --hf-file filename; looks for param-count hints like "35B" or "8x7B".
+function _inferGgufProfile(ggufPath) {
+  const s = ggufPath.toLowerCase();
+  const moe = s.match(/(\d+)x(\d+)b/);
+  let paramsB;
+  if (moe) {
+    paramsB = parseInt(moe[1]) * parseInt(moe[2]);
+  } else {
+    const m = s.match(/(\d+)b/);
+    paramsB = m ? parseInt(m[1]) : null;
+  }
+  if (paramsB === null || paramsB <= 9) return { label: 'GGUF inference (≤9B, llama.cpp)',      vram: '8+ GB',  gpus: ['RTX 4090', 'RTX 3090', 'A6000'] };
+  if (paramsB <= 35)                   return { label: 'GGUF inference (10B–35B, llama.cpp)',   vram: '24+ GB', gpus: ['RTX 4090', 'A6000', 'L40S'] };
+  return                                      { label: 'GGUF inference (36B+, llama.cpp)',      vram: '48+ GB', gpus: ['A6000', 'L40S', 'A100'] };
+}
+
 function _serveStageLabel(elapsedSec, healthPath = '/models') {
   if (healthPath === '/models') {
     if (elapsedSec < 45)  return 'Starting vLLM…';
     if (elapsedSec < 150) return 'Downloading model…';
     return 'Waiting for /v1/models…';
   }
+  if (healthPath === '/health') {
+    if (elapsedSec < 60)  return 'Starting llama-server…';
+    if (elapsedSec < 180) return 'Downloading from Hugging Face…';
+    return 'Waiting for /health…';
+  }
   if (elapsedSec < 30)  return 'Starting container…';
   if (elapsedSec < 120) return 'Container starting…';
   return `Waiting for ${healthPath}…`;
@@ -86,7 +115,9 @@ function _serveStageLabel(elapsedSec, healthPath = '/models') {
 
 function _detectHealthPath(image) {
   if (!image) return null;
-  return image.toLowerCase().includes('comfyui') ? '/system_stats' : null;
+  if (image.toLowerCase().includes('comfyui')) return '/system_stats';
+  if (image.toLowerCase().includes('llama.cpp')) return '/health';
+  return null;
 }
 
 /**
@@ -161,12 +192,34 @@ const _KNOWN_SERVE_FLAGS = new Set([
   '--gpu', '--image', '--task', '--count', '--region', '--tier', '--max-price',
   '--name', '--no-wait', '--max-cost', '--health-path', '--check-nodes',
   '--no-fallback', '--strict-capacity', '--no-expanded-search', '--env',
-  '--persistent', '--yes', '-y',
+  '--persistent', '--yes', '-y', '--runtime', '--hf-repo', '--hf-file',
 ]);
 
 export async function serveCommand(config, args, chalk) {
+  // `badgr serve template <name> [flags]` — expand template defaults then re-dispatch
+  if (args[0] === 'template') {
+    const name = args[1];
+    const t = name && TEMPLATE_MAP[name];
+    if (!t) {
+      console.error(chalk.red(`\n  Unknown template: ${name || '(none)'}\n`));
+      console.error(chalk.dim('  Run `badgr template list` to see available templates.'));
+      process.exitCode = 1;
+      return;
+    }
+    if (t.type !== 'endpoint') {
+      console.error(chalk.red(`\n  "${name}" is a job template — use: badgr run template ${name}\n`));
+      process.exitCode = 1;
+      return;
+    }
+    const overrides = parseTemplateOverrides(args.slice(2));
+    const expandedArgs = buildTemplateFlags(t, overrides);
+    console.log(chalk.dim(`  Template: ${t.title}  →  badgr serve ${expandedArgs.join(' ')}\n`));
+    return serveCommand(config, expandedArgs, chalk);
+  }
+
   const { model, flags } = parseServeArgs(args);
   const customImage = flags.image || null;
+  const isLlamaCpp = flags.runtime === 'llama.cpp';
 
   // Detect flags that ended up as positional args due to broken shell line continuation
   // (e.g. `\ ` with a trailing space instead of `\<newline>`).
@@ -188,10 +241,22 @@ export async function serveCommand(config, args, chalk) {
     return;
   }
 
-  if (!model && !customImage) {
+  if (isLlamaCpp && (!flags.hfRepo || !flags.hfFile)) {
+    console.error(chalk.red('\n  ✗ --runtime llama.cpp requires --hf-repo and --hf-file\n'));
+    console.error(chalk.dim('  Example:'));
+    console.error(chalk.dim('    badgr serve --runtime llama.cpp \\'));
+    console.error(chalk.dim('      --hf-repo org/model-repo \\'));
+    console.error(chalk.dim('      --hf-file model.gguf \\'));
+    console.error(chalk.dim('      --max-cost 10\n'));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!model && !customImage && !isLlamaCpp) {
     console.error(chalk.red('Usage: badgr serve <model>'));
     console.error(chalk.red('       badgr serve meta-llama/Llama-3.1-8B-Instruct'));
     console.error(chalk.red('       badgr serve --image ghcr.io/my-org/api:latest --gpu L40S'));
+    console.error(chalk.red('       badgr serve --runtime llama.cpp --hf-repo org/repo --hf-file model.gguf'));
     return;
   }
 
@@ -233,7 +298,20 @@ export async function serveCommand(config, args, chalk) {
 
   const effectiveTier = normalizeTier(flags.tier);
 
-  if (customImage) {
+  if (isLlamaCpp) {
+    console.log(chalk.bold('\n⚡ Serving HF GGUF (llama.cpp)\n'));
+    console.log(`  ${chalk.bold('HF Repo:')}  ${flags.hfRepo}`);
+    console.log(`  ${chalk.bold('HF File:')}  ${flags.hfFile}`);
+    console.log(`  ${chalk.bold('Runtime:')}  llama.cpp`);
+    console.log(`  ${chalk.bold('GPU:')}      ${gpuLabel}`);
+    if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}      ${flags.env.join(', ')}`);
+    if (gpu === 'AUTO') {
+      const prof = _inferGgufProfile(flags.hfFile);
+      console.log();
+      console.log(`  ${chalk.bold('Estimated workload:')}      ${prof.label}`);
+      console.log(`  ${chalk.bold('Estimated minimum VRAM:')}  ${prof.vram}`);
+    }
+  } else if (customImage) {
     console.log(chalk.bold('\n⚡ Serving custom container\n'));
     console.log(`  ${chalk.bold('Image:')}  ${customImage}`);
     console.log(`  ${chalk.bold('GPU:')}    ${gpuLabel}`);
@@ -271,7 +349,9 @@ export async function serveCommand(config, args, chalk) {
         d.workload_type === 'endpoint' &&
         (
           (model && d.model === model) ||
-          (customImage && d.image === customImage)
+          (customImage && d.image === customImage) ||
+          (isLlamaCpp && d.image === LLAMA_CPP_IMAGE &&
+           d.env?.LLAMA_ARG_HF_REPO === flags.hfRepo && d.env?.LLAMA_ARG_HF_FILE === flags.hfFile)
         )
       );
       if (duplicate) {
@@ -297,9 +377,12 @@ export async function serveCommand(config, args, chalk) {
   const effectiveRegion = flags.region ? flags.region.toUpperCase() : undefined;
 
   function buildBody(gpuOverride, tierOverride) {
+    const effectiveEnv = isLlamaCpp
+      ? { LLAMA_ARG_HF_REPO: flags.hfRepo, LLAMA_ARG_HF_FILE: flags.hfFile, ...envObj }
+      : envObj;
     return {
       ...(model ? { model } : {}),
-      ...(customImage ? { image: customImage } : {}),
+      ...(isLlamaCpp ? { image: LLAMA_CPP_IMAGE } : customImage ? { image: customImage } : {}),
       ...(flags.task ? { task: flags.task } : {}),
       gpu: gpuOverride || gpu,
       gpu_count: flags.count || 1,
@@ -307,7 +390,7 @@ export async function serveCommand(config, args, chalk) {
       max_price_per_hour: flags.maxPrice,
       name: flags.name,
       tier: tierOverride || effectiveTier,
-      ...(Object.keys(envObj).length > 0 ? { env: envObj } : {}),
+      ...(Object.keys(effectiveEnv).length > 0 ? { env: effectiveEnv } : {}),
       ...(flags.maxCost ? { max_cost_usd: flags.maxCost } : {}),
     };
   }
@@ -378,10 +461,12 @@ export async function serveCommand(config, args, chalk) {
   }
 
   // ── Determine health check path ───────────────────────────────────────────
-  // Priority: explicit --health-path > auto-detect comfyui > /models for vLLM > null (skip)
+  // Priority: explicit --health-path > llama.cpp → /health > vLLM → /models > auto-detect custom image > null
   let resolvedHealthPath;
   if (flags.healthPath) {
     resolvedHealthPath = flags.healthPath;
+  } else if (isLlamaCpp) {
+    resolvedHealthPath = '/health';
   } else if (!customImage) {
     resolvedHealthPath = '/models';
   } else {
@@ -462,7 +547,11 @@ export async function serveCommand(config, args, chalk) {
   const serveRate = dep.cost_per_hour || 0;
 
   console.log(`  ${chalk.bold('Base URL:')}     ${chalk.cyan(endpointUrl)}`);
-  if (dep.model || model) console.log(`  ${chalk.bold('Model:')}        ${dep.model || model}`);
+  if (isLlamaCpp) {
+    console.log(`  ${chalk.bold('HF Repo:')}      ${flags.hfRepo}`);
+    console.log(`  ${chalk.bold('HF File:')}      ${flags.hfFile}`);
+  }
+  else if (dep.model || model) console.log(`  ${chalk.bold('Model:')}        ${dep.model || model}`);
   if (customImage)        console.log(`  ${chalk.bold('Image:')}        ${customImage}`);
   console.log(`  ${chalk.bold('GPU:')}          ${dep.gpu_type} × ${dep.gpu_count}`);
   if (serveRate > 0) console.log(`  ${chalk.bold('Rate:')}         $${serveRate.toFixed(2)}/hr`);
@@ -480,10 +569,11 @@ export async function serveCommand(config, args, chalk) {
 
   if (endpointReady && !customImage) {
     const keySnip = config.apiKey?.slice(0, 4) || 'sk-...';
+    const sdkModel = isLlamaCpp ? 'default' : (dep.model || model);
     console.log(`  ${chalk.bold('Use with OpenAI SDK:')}`);
     console.log(chalk.dim(`    from openai import OpenAI`));
     console.log(chalk.dim(`    client = OpenAI(base_url="${endpointUrl}", api_key="${keySnip}...")`));
-    console.log(chalk.dim(`    resp = client.chat.completions.create(model="${dep.model || model}", messages=[...])`));
+    console.log(chalk.dim(`    resp = client.chat.completions.create(model="${sdkModel}", messages=[...])`));
     console.log();
   }
 }