badgr-cli 1.1.5 → 1.1.7

package/src/commands/node.js

@@ -0,0 +1,250 @@
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { execFileSync, spawn } from 'child_process';
+import { ensureLoggedInReady } from '../onboarding.js';
+import { connectNode, listNodes, inspectNode, disableNode, removeNode } from '../api.js';
+import { detectGpus } from '../gpuDoctor/gpuInfo.js';
+
+/**
+ * badgr node connect [--name <name>]
+ * badgr node list
+ * badgr node inspect <node>
+ * badgr node disable <node>
+ * badgr node remove <node>
+ *
+ * BYO GPU (Phase 1). `connect` registers this machine as a private capacity
+ * source (server-side) AND
+ * starts the badgr-node worker daemon (src/nodeWorker/node_worker.py,
+ * shipped inside this npm package) so the promised self-serve flow —
+ * `npm install -g badgr-cli && badgr node connect` — actually leaves a
+ * running worker, not just a database row. It never becomes
+ * marketplace-listed on its own.
+ */
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const WORKER_SCRIPT = path.join(__dirname, '..', 'nodeWorker', 'node_worker.py');
+
+/**
+ * Shared `--target <node>` resolution for `badgr run`/`badgr serve` — CLI
+ * sugar over the explicit customer_node target the API takes. Resolves a node name to its
+ * node_id; a bare `node_…` id is used as-is. Returns `{ ok: true, nodeId }`
+ * on success (`nodeId` is `undefined` when `target` is falsy — leaves the
+ * caller's body.target unset, i.e. today's cloud-provider search,
+ * unchanged) or `{ ok: false }` after printing a user-facing error, in
+ * which case the caller should set `process.exitCode = 1` and return.
+ */
+export async function resolveTargetNodeId(config, target, chalk) {
+  if (!target) return { ok: true, nodeId: undefined };
+  if (target.startsWith('node_')) return { ok: true, nodeId: target };
+  let nodes;
+  try {
+    nodes = await listNodes(config);
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ Could not resolve --target ${target}: ${err.message}\n`));
+    return { ok: false };
+  }
+  const match = nodes.find((n) => n.name === target || n.node_id === target);
+  if (!match) {
+    console.error(chalk.red(`\n  ✗ No connected node named "${target}". Run \`badgr node list\`.\n`));
+    return { ok: false };
+  }
+  return { ok: true, nodeId: match.node_id };
+}
+
+function dockerAvailable() {
+  try {
+    execFileSync('docker', ['info'], { stdio: 'ignore', timeout: 5000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function python3Available() {
+  try {
+    execFileSync('python3', ['--version'], { stdio: 'ignore', timeout: 5000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function startWorker(config, node) {
+  const logDir = path.join(os.homedir(), '.badgr', 'logs');
+  fs.mkdirSync(logDir, { recursive: true });
+  const logPath = path.join(logDir, `node-${node.node_id}.log`);
+  const workerArgs = [
+    WORKER_SCRIPT, '--node-id', node.node_id, '--api-key', config.apiKey, '--base-url', config.baseUrl,
+  ];
+  // Header line makes it obvious in the log file which `connect` invocation
+  // spawned this worker run (helpful when a node is connected more than
+  // once, or the worker is restarted) without needing to inspect argv.
+  fs.appendFileSync(
+    logPath,
+    `\n=== ${new Date().toISOString()} badgr node connect: spawning worker for ${node.node_id} (base_url=${config.baseUrl}) ===\n`,
+  );
+  const out = fs.openSync(logPath, 'a');
+  const child = spawn('python3', workerArgs, { detached: true, stdio: ['ignore', out, out] });
+  child.unref();
+  return { pid: child.pid, logPath };
+}
+
+function detectHardware() {
+  const gpuProbe = detectGpus();
+  const primary = gpuProbe.gpus[0];
+  return {
+    gpu_vendor: gpuProbe.vendor,
+    gpu_model: primary ? primary.name : null,
+    gpu_count: gpuProbe.gpus.length,
+    vram_gb: primary ? primary.vramTotalGb : null,
+    // Feeds byo_preflight.run_preflight()'s required_gpu_architecture check
+    // (backend/byo_preflight.py) -- AMD reports a gfx#### string (e.g.
+    // "gfx1030"), NVIDIA reports its compute capability (e.g. "8.9"), both
+    // read straight off this machine's own GPU(s), never guessed.
+    gpu_architecture: primary ? primary.architecture : null,
+    driver_version: gpuProbe.driverVersion,
+    cuda_version: gpuProbe.cudaVersion,
+    cpu_count: os.cpus().length,
+    memory_gb: Math.round(os.totalmem() / (1024 ** 3)),
+    platform: os.platform(),
+    docker: dockerAvailable(),
+  };
+}
+
+function parseFlags(args) {
+  const flags = {};
+  let i = 0;
+  while (i < args.length) {
+    if (args[i] === '--name') { flags.name = args[++i]; i++; continue; }
+    i++;
+  }
+  return flags;
+}
+
+function resolveNodeIdArg(config, args) {
+  return args.find((a) => !a.startsWith('--'));
+}
+
+export async function nodeCommand(config, args, chalk) {
+  const sub = args[0];
+  const rest = args.slice(1);
+  config = await ensureLoggedInReady(config, chalk);
+
+  if (sub === 'connect') {
+    const flags = parseFlags(rest);
+    const hardware = detectHardware();
+    console.log(chalk.dim(
+      `  Detected: vendor=${hardware.gpu_vendor || 'none'} gpu_count=${hardware.gpu_count} gpu_model=${hardware.gpu_model || 'none'} `
+      + `arch=${hardware.gpu_architecture || 'none'} driver=${hardware.driver_version || 'none'} `
+      + `docker=${hardware.docker} platform=${hardware.platform}`,
+    ));
+    if (!hardware.gpu_count) {
+      console.log(chalk.yellow('\n  No GPU detected (nvidia-smi and rocm-smi both not found or returned nothing).'));
+      console.log(chalk.dim('  BYO GPU currently supports Linux + NVIDIA or AMD/ROCm.\n'));
+    }
+    if (!hardware.docker) {
+      console.log(chalk.yellow('  Docker was not detected — badgr-node needs Docker to run workloads.\n'));
+    }
+    let node;
+    try {
+      node = await connectNode(config, { name: flags.name, hardware });
+    } catch (err) {
+      console.error(chalk.red(`\n  ✗ Failed to connect node: ${err.message}\n`));
+      process.exit(1);
+    }
+    console.log(chalk.green(`\n  ✓ Connected ${chalk.bold(node.name)} (${node.node_id})`));
+    console.log(chalk.dim(`    ${hardware.gpu_count} × ${hardware.gpu_model || 'unknown GPU'} — private, not listed on the marketplace\n`));
+
+    const hasPython3 = python3Available();
+    if (!hardware.gpu_count || !hardware.docker || !hasPython3) {
+      const missing = [
+        !hardware.gpu_count && 'GPU (nvidia-smi/rocm-smi)',
+        !hardware.docker && 'Docker',
+        !hasPython3 && 'python3',
+      ].filter(Boolean).join(', ');
+      console.log(chalk.yellow(`  Not starting the worker automatically — missing: ${missing}.`));
+      console.log(`  Once fixed, start it with:`);
+      console.log(chalk.cyan(`    python3 "${WORKER_SCRIPT}" --node-id ${node.node_id} --api-key <your-api-key>\n`));
+      return;
+    }
+
+    const { pid, logPath } = startWorker(config, node);
+    console.log(`  Worker started (pid ${pid}) — this node is now receiving jobs.`);
+    console.log(chalk.dim(`    Logs: ${logPath}\n`));
+    return;
+  }
+
+  if (sub === 'list') {
+    let nodes;
+    try {
+      nodes = await listNodes(config);
+    } catch (err) {
+      console.error(chalk.red(`\n  ✗ Failed to list nodes: ${err.message}\n`));
+      process.exit(1);
+    }
+    if (!nodes.length) {
+      console.log(chalk.dim('\n  No connected nodes. Run `badgr node connect` on a machine with an NVIDIA or AMD/ROCm GPU.\n'));
+      return;
+    }
+    console.log(chalk.bold('\nMy GPUs\n'));
+    for (const n of nodes) {
+      const status = n.online ? chalk.green('online') : chalk.dim('offline');
+      const hw = n.hardware || {};
+      console.log(`  ${chalk.bold(n.name)}  ${chalk.dim(n.node_id)}`);
+      console.log(`    ${hw.gpu_count || 0} × ${hw.gpu_model || 'unknown'}   ${status}   ${n.visibility}`);
+    }
+    console.log();
+    return;
+  }
+
+  if (sub === 'inspect') {
+    const nodeId = resolveNodeIdArg(config, rest);
+    if (!nodeId) { console.error(chalk.red('\n  Usage: badgr node inspect <node-id>\n')); process.exit(1); }
+    let node;
+    try {
+      node = await inspectNode(config, nodeId);
+    } catch (err) {
+      console.error(chalk.red(`\n  ✗ ${err.message}\n`));
+      process.exit(1);
+    }
+    console.log(chalk.bold(`\n${node.name}  ${chalk.dim(node.node_id)}\n`));
+    console.log(JSON.stringify(node, null, 2));
+    console.log();
+    return;
+  }
+
+  if (sub === 'disable') {
+    const nodeId = resolveNodeIdArg(config, rest);
+    if (!nodeId) { console.error(chalk.red('\n  Usage: badgr node disable <node-id>\n')); process.exit(1); }
+    try {
+      await disableNode(config, nodeId);
+    } catch (err) {
+      console.error(chalk.red(`\n  ✗ ${err.message}\n`));
+      process.exit(1);
+    }
+    console.log(chalk.green(`\n  ✓ Disabled ${nodeId} — it will no longer receive new jobs.\n`));
+    return;
+  }
+
+  if (sub === 'remove') {
+    const nodeId = resolveNodeIdArg(config, rest);
+    if (!nodeId) { console.error(chalk.red('\n  Usage: badgr node remove <node-id>\n')); process.exit(1); }
+    try {
+      await removeNode(config, nodeId);
+    } catch (err) {
+      console.error(chalk.red(`\n  ✗ ${err.message}\n`));
+      process.exit(1);
+    }
+    console.log(chalk.green(`\n  ✓ Removed ${nodeId}\n`));
+    return;
+  }
+
+  console.log(chalk.bold('\nbadgr node — manage your own connected GPUs\n'));
+  console.log('  badgr node connect [--name <name>]   Connect this machine\'s GPU (private)');
+  console.log('  badgr node list                      List your connected nodes');
+  console.log('  badgr node inspect <node-id>          Show one node\'s details');
+  console.log('  badgr node disable <node-id>          Stop a node from receiving new jobs');
+  console.log('  badgr node remove <node-id>            Disconnect and forget a node\n');
+}

package/src/commands/run.js

@@ -14,6 +14,7 @@ import { ensureBadgrReady } from '../onboarding.js';
 import { VM_CLASSES, parseGbSize } from '../spec.js';
 import { parseEnvFlag } from '../envFlag.js';
 import { isMetaLogLine, isErrorLogLine, parseProviderStatusLine } from '../deploymentLog.js';
+import { resolveTargetNodeId } from './node.js';
 
 function vmClassLine(sizeKey) {
   const vmClass = VM_CLASSES[sizeKey];
@@ -54,6 +55,7 @@ export function parseRunArgs(args) {
   let i = 0;
   while (i < flagArgs.length) {
     if (flagArgs[i] === '--gpu')            { flags.gpu = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--target')         { flags.target = flagArgs[++i]; i++; continue; }
     if (flagArgs[i] === '--image')          { flags.image = flagArgs[++i]; i++; continue; }
     if (flagArgs[i] === '--count')          { flags.count = parseInt(flagArgs[++i], 10); i++; continue; }
     if (flagArgs[i] === '--region')         { flags.region = flagArgs[++i]; i++; continue; }
@@ -128,7 +130,7 @@ function redactEnvForDisplay(envList) {
   }).join(', ');
 }
 
-// Mirror of backend workload_profile.py — kept in sync for pre-flight display.
+// Mirror of the backend's own workload-profile logic — kept in sync for pre-flight display.
 const _PROFILES = {
   smoke_test:       { label: 'smoke test',            vram: '4 GB',    gpus: ['RTX 3080', 'RTX 3090', 'RTX 4090'] },
   lora_finetune:    { label: 'fine-tuning (LoRA)',     vram: '40+ GB',  gpus: ['A6000', 'L40S', 'A100'] },
@@ -392,7 +394,7 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
 
 // Known badgr run flags — used to detect broken shell line continuation.
 const _KNOWN_RUN_FLAGS = new Set([
-  '--gpu', '--image', '--count', '--region', '--tier', '--smoke', '--max-price', '--name',
+  '--gpu', '--target', '--image', '--count', '--region', '--tier', '--smoke', '--max-price', '--name',
   '--detach', '--no-detach', '--fallback', '--no-fallback', '--strict-capacity',
   '--no-expanded-search', '--max-runtime', '--max-cost', '--min-vram', '--gpu-memory',
   '--cpu', '--memory', '--no-gpu', '--env',
@@ -495,7 +497,7 @@ export async function runCommand(config, args, chalk, opts = {}) {
   // callers (badgr launch's agent workloads), never parsed from a shell
   // string. Passed to the backend as command_argv, which the worker always
   // prefers over the legacy cmd string + shlex.split() path (see
-  // images/badgr-job-runner/entrypoint.py). flags.cmd stays the
+  // the worker image's own entrypoint). flags.cmd stays the
   // human-readable display string only.
   const cmdArgv = Array.isArray(opts.cmdArgv) ? opts.cmdArgv : undefined;
   const cmdName = isLaunch ? 'badgr launch' : 'badgr run';
@@ -903,6 +905,13 @@ export async function runCommand(config, args, chalk, opts = {}) {
     console.log(chalk.dim(`  API: ${config.baseUrl}`));
   }
 
+  // --target <node> — see node.js's resolveTargetNodeId for the shared
+  // resolution (also used by serve.js). Omitting --target leaves
+  // body.target unset — today's cloud-provider search, unchanged.
+  const _targetResolved = await resolveTargetNodeId(config, flags.target, chalk);
+  if (!_targetResolved.ok) { process.exitCode = 1; return; }
+  const targetNodeId = _targetResolved.nodeId;
+
   function buildBody(gpuOverride, tierOverride) {
     const effectiveRegion = flags.region ? flags.region.toUpperCase() : undefined;
     return {
@@ -932,6 +941,7 @@ export async function runCommand(config, args, chalk, opts = {}) {
       ...(flags.artifacts?.length ? { output_paths: flags.artifacts } : {}),
       ...(flags.agentName ? { agent: flags.agentName } : {}),
       ...(flags.size ? { size: flags.size } : {}),
+      ...(targetNodeId ? { target: { type: 'customer_node', node_id: targetNodeId } } : {}),
     };
   }
 
@@ -999,7 +1009,7 @@ export async function runCommand(config, args, chalk, opts = {}) {
   // Show what was actually provisioned, not just what was requested — only
   // when the caller asked for a resource floor and the provider reported
   // enough to say something concrete (best-effort; not every provider
-  // exposes vcpu/ram/vram per-offer, see deployment_service.py's
+  // exposes vcpu/ram/vram per-offer, see the backend's own
   // chosen_instance.extra enrichment).
   if (flags.cpu || flags.memory || flags.minVram) {
     const parts = [];

package/src/commands/serve.js

@@ -7,6 +7,7 @@ import { requireApiKey, webBaseUrl } from '../config.js';
 import { parseEnvFlag } from '../envFlag.js';
 import { TEMPLATE_MAP, buildTemplateFlags, parseTemplateOverrides, BLESSED_VLLM_MODELS, isLikelyGatedModel } from '../catalog.js';
 import { stage as _stage, stageDone as _stageDone, writeBlock as _writeBlock, clearBlock as _clearBlock, renderLiveBlock as _renderLiveBlock, printFailureClass as _printFailureClass, printCapacityPreview, formatTierLabel } from '../progress.js';
+import { resolveTargetNodeId } from './node.js';
 
 const LLAMA_CPP_IMAGE = 'michaelmanleyx/llama-cpp:server-cuda';
 
@@ -16,15 +17,38 @@ const LLAMA_CPP_IMAGE = 'michaelmanleyx/llama-cpp:server-cuda';
  * 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
+ * badgr serve org/Qwen3-27B-NVFP4 --vllm-arg --quantization=nvfp4 --vllm-arg --max-model-len=32768
+ * badgr serve org/Qwen3-27B-NVFP4 -- --quantization nvfp4 --max-model-len 32768
  *
  * GPU defaults to "AUTO" — backend infers from model size.
+ *
+ * --vllm-arg and the `--` passthrough form both feed the same extra_args
+ * list sent to POST /v1/serve, which appends them verbatim to vLLM's launch
+ * command after --model/--served-model-name (see
+ * the backend's own ServeBody.extra_args and
+ * cache_layer.build_vllm_launch). Only meaningful for the vLLM path (a
+ * HuggingFace --model, with or without --image) — ignored for --runtime
+ * llama.cpp and other managed runtimes, which don't build a vLLM command.
  */
 export function parseServeArgs(args) {
   const flags = {};
   const positional = [];
   let i = 0;
   while (i < args.length) {
+    if (args[i] === '--') {
+      // Everything after a bare `--` is passed through verbatim as vLLM
+      // launch args — same destination as repeated --vllm-arg, just
+      // without needing to prefix each one.
+      if (!flags.vllmArgs) flags.vllmArgs = [];
+      flags.vllmArgs.push(...args.slice(i + 1));
+      break;
+    }
+    if (args[i] === '--vllm-arg')   {
+      if (!flags.vllmArgs) flags.vllmArgs = [];
+      flags.vllmArgs.push(args[++i]); i++; continue;
+    }
     if (args[i] === '--gpu')        { flags.gpu = args[++i]; i++; continue; }
+    if (args[i] === '--target')     { flags.target = args[++i]; i++; continue; }
     if (args[i] === '--image')      { flags.image = args[++i]; i++; continue; }
     if (args[i] === '--task')       { flags.task = args[++i]; i++; continue; }
     if (args[i] === '--count')      { flags.count = parseInt(args[++i], 10); i++; continue; }
@@ -73,7 +97,7 @@ function envObjHasHfToken(envList) {
 // Splits into delimiter-bounded segments first so a version number like "2.5"
 // in "Qwen2.5-0.5B" is never mistaken for the param count — only a segment that
 // IS entirely "<digits>b"/"<digits>m" or "<digits>x<digits>b" counts as a size
-// hint. Mirrors backend/workload_profile.py's own `_extract_params_b` --
+// hint. Mirrors the backend's own parameter-extraction logic --
 // keep the two in sync; a drift between them means this CLI preview and the
 // backend's real GPU selection could show a different workload class for
 // the same model.
@@ -95,13 +119,13 @@ export function _extractParamsB(name) {
   return null;
 }
 
-// Mirror of backend workload_profile.py infer_profile_from_model — for pre-flight display.
+// Mirror of the backend's own model-profile inference — for pre-flight display.
 // Sizing is only asserted when a param-count hint is found in the name; unknown
 // sizing falls back to the 7B–8B/24GB+ default rather than guessing small or large.
-// GPU lists match workload_profile.py's real preferred_gpus for each profile
+// GPU lists match the backend's own preferred_gpus for each profile
 // (not just a cosmetic display choice) -- "L4" previously appeared in the
 // ≤3B bucket here but is not an actual GPU type this codebase ever routes to
-// (see overflow_providers.py's GPU catalog), so it never matched anything
+// (see the backend's own GPU catalog), so it never matched anything
 // real; the cheapest-available-first list below is the one the backend's
 // own "inference_tiny" profile actually searches.
 export function _inferServeProfile(modelName) {
@@ -113,7 +137,7 @@ export function _inferServeProfile(modelName) {
   return                      { label: 'inference (70B+ model)',    vram: '80+ GB', gpus: ['H100', 'A100'] };
 }
 
-// Mirror of backend workload_profile.py infer_profile_from_gguf.
+// Mirror of the backend's own GGUF-profile inference.
 // Accepts the --hf-file filename; looks for param-count hints like "35B" or "8x7B".
 function _inferGgufProfile(ggufPath) {
   const paramsB = _extractParamsB(ggufPath);
@@ -151,7 +175,12 @@ function _resolveHealthPath({ healthPath, isLlamaCpp, customImage, task }) {
  * directly. The backend does the real health_path probing (see
  * DeploymentService.check_endpoint_readiness); a pod reporting RUNNING only
  * means infrastructure is up, not that the app inside is serving.
- * Returns { ready: boolean, timedOut: boolean, depFailed: boolean, failReason?: string }
+ * Returns { ready: boolean, timedOut: boolean, depFailed: boolean, failReason?: string,
+ *           dep? }. `dep` (only present when ready) is the last polled
+ * /deployments/{id} response — carries supports_completions/
+ * supports_chat_completions, probed server-side once the endpoint first
+ * reports ready, so the caller's final usage example can match what the
+ * model actually serves instead of guessing.
  */
 // vLLM cold start (model download + load) often exceeds 5 min on first boot.
 const VLLM_SERVE_WAIT_MS = 15 * 60 * 1000;
@@ -183,7 +212,7 @@ async function waitForEndpoint(deploymentId, config, timeoutMs = VLLM_SERVE_WAIT
       }
       if (dep.endpoint_ready) {
         if (blockLines > 0) { _clearBlock(blockLines); blockLines = 0; }
-        return { ready: true, timedOut: false, depFailed: false };
+        return { ready: true, timedOut: false, depFailed: false, dep };
       }
 
       const now     = Date.now();
@@ -231,7 +260,7 @@ async function validateComfyNodes(baseUrl, nodeList, chalk) {
 
 // Known badgr serve flags — used to detect broken shell line continuation.
 const _KNOWN_SERVE_FLAGS = new Set([
-  '--gpu', '--image', '--task', '--count', '--region', '--tier', '--max-price',
+  '--gpu', '--target', '--image', '--task', '--count', '--region', '--tier', '--max-price',
   '--name', '--no-wait', '--max-cost', '--idle-timeout', '--health-path', '--check-nodes',
   '--no-fallback', '--strict-capacity', '--no-expanded-search', '--env',
   '--persistent', '--yes', '-y', '--runtime', '--hf-repo', '--hf-file', '--dry-run',
@@ -536,6 +565,7 @@ export async function serveCommand(config, args, chalk) {
   if (flags.gpu) headerLines.push(['GPU', gpuLabel]);
   if (flags.task) headerLines.push(['Task', flags.task]);
   if (flags.env?.length) headerLines.push(['Env', flags.env.join(', ')]);
+  if (flags.vllmArgs?.length) headerLines.push(['vLLM args', flags.vllmArgs.join(' ')]);
   if (flags.dryRun) {
     headerLines.push(['Tier', formatTierLabel(effectiveTier)]);
     const previewHealthPath = _resolveHealthPath({ healthPath: flags.healthPath, isLlamaCpp, customImage, task: flags.task });
@@ -612,6 +642,13 @@ export async function serveCommand(config, args, chalk) {
 
   const effectiveRegion = flags.region ? flags.region.toUpperCase() : undefined;
 
+  // --target <node> — see node.js's resolveTargetNodeId for the shared
+  // resolution (also used by run.js). Omitting --target leaves body.target
+  // unset — today's cloud-provider search, unchanged.
+  const _targetResolved = await resolveTargetNodeId(config, flags.target, chalk);
+  if (!_targetResolved.ok) { process.exitCode = 1; return; }
+  const targetNodeId = _targetResolved.nodeId;
+
   function buildBody(gpuOverride, tierOverride) {
     const effectiveEnv = isLlamaCpp
       ? { LLAMA_ARG_HF_REPO: flags.hfRepo, LLAMA_ARG_HF_FILE: flags.hfFile, ...envObj }
@@ -631,6 +668,8 @@ export async function serveCommand(config, args, chalk) {
       ...(flags.maxCost ? { max_cost_usd: flags.maxCost } : {}),
       ...(flags.idleTimeout ? { idle_timeout_minutes: flags.idleTimeout } : {}),
       ...(flags.healthPath ? { health_path: flags.healthPath } : {}),
+      ...(flags.vllmArgs?.length ? { extra_args: flags.vllmArgs } : {}),
+      ...(targetNodeId ? { target: { type: 'customer_node', node_id: targetNodeId } } : {}),
     };
   }
 
@@ -793,6 +832,11 @@ export async function serveCommand(config, args, chalk) {
     if (endpointReady) {
       console.log(chalk.dim(_stage(healthStageN, STAGE_TOTAL, 'Checking endpoint health...')));
       console.log(chalk.green(_stage(readyStageN, STAGE_TOTAL, 'Ready')));
+      if (healthResult.dep) {
+        dep.supports_completions = healthResult.dep.supports_completions;
+        dep.supports_chat_completions = healthResult.dep.supports_chat_completions;
+        dep.capability_source = healthResult.dep.capability_source;
+      }
     } else {
       updateReceipt(rcptId, { status: 'health_check_timeout' });
     }
@@ -820,7 +864,14 @@ export async function serveCommand(config, args, chalk) {
     console.log();
   }
 
-  console.log(`  ${chalk.bold('Base URL:')}     ${chalk.cyan(endpointUrl)}`);
+  // dep.service_url is the Badgr-owned https://<id>.serve.aibadgr.com URL
+  // once that proxy is actually live (server-side) --
+  // until then it's absent/equal to endpointUrl, so this falls back to the
+  // raw provider URL exactly as before. Only the customer-facing display
+  // and usage examples switch to it; polling/comfy-node validation above
+  // still talk to the real internal endpointUrl directly.
+  const displayUrl = dep.service_url || endpointUrl;
+  console.log(`  ${chalk.bold('Base URL:')}     ${chalk.cyan(displayUrl)}`);
   if (isLlamaCpp) {
     console.log(`  ${chalk.bold('HF Repo:')}      ${flags.hfRepo}`);
     console.log(`  ${chalk.bold('HF File:')}      ${flags.hfFile}`);
@@ -843,7 +894,7 @@ export async function serveCommand(config, args, chalk) {
 
   if (endpointReady && isOllama) {
     console.log(`  ${chalk.bold('Test with curl:')}`);
-    console.log(chalk.dim(`    curl ${endpointUrl}/api/generate \\`));
+    console.log(chalk.dim(`    curl ${displayUrl}/api/generate \\`));
     console.log(chalk.dim(`      -H "Content-Type: application/json" \\`));
     console.log(chalk.dim(`      -d '{"model":"${dep.model || effectiveModel}","prompt":"Hello","stream":false}'`));
     console.log();
@@ -860,13 +911,45 @@ export async function serveCommand(config, args, chalk) {
       console.log(`  ${chalk.bold('API key:')}      ${chalk.yellow(dep.endpoint_api_key)}`);
       console.log(chalk.dim('    Shown once — copy it now. This key is scoped to this endpoint only.'));
     }
+    // dep.supports_chat_completions is probed server-side (see backend
+    // the backend's own model-capabilities lookup): a live call against this exact endpoint is
+    // authoritative when it's reachable (dep.capability_source ===
+    // "runtime"); otherwise it falls back to a best-effort hint from the
+    // model's public HF chat-template config (capability_source ===
+    // "hf_hint"). `true`/`false` here always mean one of those two actually
+    // produced a real signal -- a model without a chat template (e.g.
+    // facebook/opt-125m) answers /v1/completions but 400s on
+    // /v1/chat/completions, so a generic chat example would be wrong.
+    // `undefined`/`null` means NEITHER produced a signal (auth-protected
+    // endpoint + HF lookup failed, or a non-vLLM/task image) -- unlike this
+    // command's old behavior, that must never silently default to showing
+    // a chat example that might not work; show neither example instead.
+    const noTask = !flags.task;
+    const chatKnown = dep.supports_chat_completions === true || dep.supports_chat_completions === false;
+    const showChatExample = noTask && chatKnown && dep.supports_chat_completions === true;
+    const showCompletionsExample = noTask && chatKnown && dep.supports_chat_completions === false;
+    const capabilityUnverified = noTask && !chatKnown;
+    const unconfirmedNote = dep.capability_source === 'hf_hint'
+      ? chalk.dim('    (based on the model\'s public Hugging Face config — not confirmed against this live endpoint)')
+      : null;
     console.log(`  ${chalk.bold('Test with curl:')}`);
-    console.log(chalk.dim(`    curl ${endpointUrl}/chat/completions \\`));
-    console.log(chalk.dim(`      -H "Authorization: Bearer ${authKey}" -H "Content-Type: application/json" \\`));
-    console.log(chalk.dim(`      -d '{"model":"${sdkModel}","messages":[{"role":"user","content":"Hello"}]}'`));
+    if (showChatExample) {
+      console.log(chalk.dim(`    curl ${displayUrl}/chat/completions \\`));
+      console.log(chalk.dim(`      -H "Authorization: Bearer ${authKey}" -H "Content-Type: application/json" \\`));
+      console.log(chalk.dim(`      -d '{"model":"${sdkModel}","messages":[{"role":"user","content":"Hello"}]}'`));
+      if (unconfirmedNote) console.log(unconfirmedNote);
+    } else if (showCompletionsExample) {
+      console.log(chalk.dim(`    curl ${displayUrl}/completions \\`));
+      console.log(chalk.dim(`      -H "Authorization: Bearer ${authKey}" -H "Content-Type: application/json" \\`));
+      console.log(chalk.dim(`      -d '{"model":"${sdkModel}","prompt":"Hello","max_tokens":32}'`));
+      if (unconfirmedNote) console.log(unconfirmedNote);
+    } else if (capabilityUnverified) {
+      console.log(chalk.yellow('    Capability not verified yet — check available models first:'));
+      console.log(chalk.dim(`    curl ${displayUrl}/models -H "Authorization: Bearer ${authKey}"`));
+    }
     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="${authKey}")`));
+    console.log(chalk.dim(`    client = OpenAI(base_url="${displayUrl}", api_key="${authKey}")`));
     if (flags.task === 'transcribe') {
       console.log(chalk.dim(`    with open("audio.mp3", "rb") as f:`));
       console.log(chalk.dim(`        t = client.audio.transcriptions.create(model="${sdkModel}", file=f, response_format="text")`));
@@ -875,8 +958,13 @@ export async function serveCommand(config, args, chalk) {
       console.log(chalk.dim(`    # resp.data[0].b64_json contains the base64-encoded PNG`));
     } else if (flags.task === 'embed') {
       console.log(chalk.dim(`    resp = client.embeddings.create(model="${sdkModel}", input=["hello world"])`));
-    } else {
+    } else if (showChatExample) {
       console.log(chalk.dim(`    resp = client.chat.completions.create(model="${sdkModel}", messages=[{"role": "user", "content": "Hello"}])`));
+    } else if (showCompletionsExample) {
+      console.log(chalk.dim(`    resp = client.completions.create(model="${sdkModel}", prompt="Hello", max_tokens=32)`));
+      console.log(chalk.dim(`    # this model has no chat template — /v1/chat/completions returns 400 for it`));
+    } else {
+      console.log(chalk.dim(`    resp = client.models.list()  # check capability_unverified — chat vs completions support isn't confirmed yet`));
     }
     console.log();
     if (flags.idleTimeout) {

package/src/commands/status.js

@@ -1,19 +1,27 @@
 import { listDeployments as localDeployments } from '../store.js';
-import { listDeployments as apiDeployments, listAllActiveDeploymentsAdmin } from '../api.js';
+import { listDeployments as apiDeployments } from '../api.js';
 
 export async function statusCommand(config, args, chalk) {
   const isAdmin = args.includes('--admin');
   let deployments = [];
 
   if (isAdmin) {
-    // Admin-only (michaelhireitem@gmail.com): every user's active
-    // deployments, not just the caller's own -- see
-    // deployment_routes.py's GET /v1/admin/deployments/active. A non-admin
-    // account gets a plain 403 here, same as any other access-denied call.
+    // Admin-only: every user's active deployments, not just the caller's
+    // own. Gated server-side by an internal admin allowlist -- a
+    // non-admin account gets a plain 403 here, same as any other
+    // access-denied call. See ../admin.js for why this is a separate,
+    // never-publicly-exported module.
     if (!config.apiKey) {
       console.log(chalk.red('\n  Sign in required: badgr login\n'));
       return;
     }
+    let listAllActiveDeploymentsAdmin;
+    try {
+      ({ listAllActiveDeploymentsAdmin } = await import('../admin.js')); // oss-safe: guarded by try/catch, no-ops when admin.js is absent from a public export
+    } catch {
+      console.log(chalk.red('\n  Admin mode is not available in this build.\n'));
+      return;
+    }
     try {
       const data = await listAllActiveDeploymentsAdmin(config);
       deployments = data?.deployments ?? [];

package/src/commands/train.js

@@ -116,7 +116,7 @@ export function parseTrainLoraArgs(args) {
   return flags;
 }
 
-// Mirror of backend LORA_PRESETS (jobs_routes.py) — display only, server is authoritative.
+// Mirror of the backend's own LORA_PRESETS — display only, server is authoritative.
 export const LORA_PRESET_INFO = {
   small:  { gpu_type: 'RTX_4090', rank: 16, epochs: 3, description: 'Fast, low-cost — good default for most datasets' },
   medium: { gpu_type: 'A100',     rank: 32, epochs: 5, description: 'Larger rank/more epochs — bigger datasets or higher quality' },

package/src/config.js

@@ -29,25 +29,6 @@ export function normalizeBaseUrl(url) {
   return trimmed.endsWith('/v1') ? trimmed : `${trimmed}/v1`;
 }
 
-const DEFAULT_WEB_URL = 'https://aibadgr.com';
-const LOCAL_WEB_URL = 'http://localhost:3000';
-
-// The frontend origin to link out to (Run page, evidence/repro page, etc).
-// start-local.sh points config.baseUrl at http://localhost:8000/v1 so the
-// CLI's API calls hit the local backend; when it does, links the CLI prints
-// should point at the local frontend (localhost:3000) too, not production.
-export function webBaseUrl(config) {
-  const envWeb = process.env.BADGR_WEB_URL?.trim().replace(/\/+$/, '');
-  if (envWeb) return envWeb;
-  try {
-    const { hostname } = new URL(config?.baseUrl || DEFAULTS.baseUrl);
-    if (hostname === 'localhost' || hostname === '127.0.0.1') return LOCAL_WEB_URL;
-  } catch {
-    // fall through to the default below
-  }
-  return DEFAULT_WEB_URL;
-}
-
 function applyEnvOverrides(config) {
   const envBase = process.env.BADGR_API_URL?.trim();
   if (envBase) config.baseUrl = normalizeBaseUrl(envBase);
@@ -91,6 +72,18 @@ export function saveConfig(updates, configFile = CONFIG_FILE) {
   return merged;
 }
 
+/**
+ * The Badgr dashboard's web origin. A localhost API base (local dev
+ * backend) maps to the local frontend dev server; every other API base
+ * (including a self-hosted/custom one) still points at the production
+ * dashboard, since that's the only place the dashboard is hosted today.
+ */
+export function webBaseUrl(config) {
+  const base = normalizeBaseUrl(config?.baseUrl);
+  if (/^https?:\/\/localhost(?::\d+)?\//.test(base)) return 'http://localhost:3000';
+  return DEFAULTS.baseUrl.replace(/\/v1$/, '');
+}
+
 export function requireApiKey(config) {
   if (!config.apiKey) throw new Error('No API key configured. Run: badgr login');
   return config.apiKey;