badgr-cli 1.0.43 → 1.0.45

package/tests/detect.test.js

@@ -0,0 +1,191 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { detectWorkload, workloadTypeLabel } from '../src/detect.js';
+
+let tmpRoot;
+
+function makeProject(files) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'badgr-detect-'));
+  for (const [rel, content] of Object.entries(files)) {
+    const abs = path.join(dir, rel);
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, content);
+  }
+  return dir;
+}
+
+beforeEach(() => { tmpRoot = []; });
+afterEach(() => {
+  for (const dir of tmpRoot) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+function project(files) {
+  const dir = makeProject(files);
+  tmpRoot.push(dir);
+  return dir;
+}
+
+describe('detectWorkload — missing / empty directory', () => {
+  it('reports an error without throwing for a missing directory', () => {
+    const report = detectWorkload('/nonexistent/badgr-detect-fixture');
+    expect(report.error).toBeTruthy();
+    expect(report.confidence).toBe('low');
+  });
+
+  it('is low confidence with no command for an empty directory', () => {
+    const dir = project({});
+    const report = detectWorkload(dir);
+    expect(report.command).toBeNull();
+    expect(report.confidence).toBe('low');
+  });
+});
+
+describe('detectWorkload — plain Python CUDA script', () => {
+  it('finds the entry point and requirements, classifies as custom', () => {
+    const dir = project({
+      'train.py': `
+import torch
+model = torch.nn.Linear(10, 10).cuda()
+for step in range(100):
+    optimizer.step()
+`,
+      'requirements.txt': 'torch\nnumpy\n',
+      'output/.gitkeep': '',
+    });
+    const report = detectWorkload(dir);
+    expect(report.command).toBe('python train.py');
+    expect(report.requirements).toContain('requirements.txt');
+    expect(report.outputs).toContain('output/');
+    expect(report.workloadType).toBe('training');
+    expect(['medium', 'high']).toContain(report.confidence);
+  });
+});
+
+describe('detectWorkload — vLLM endpoint', () => {
+  it('classifies as endpoint and detects the port', () => {
+    const dir = project({
+      'server.py': `
+from vllm import LLM
+import uvicorn
+app = None
+
+if __name__ == "__main__":
+    uvicorn.run(app, port=8000)
+`,
+      'requirements.txt': 'vllm\nfastapi\nuvicorn\n',
+    });
+    const report = detectWorkload(dir);
+    expect(report.command).toBe('python server.py');
+    expect(report.workloadType).toBe('endpoint');
+    expect(report.ports).toContain(8000);
+    expect(report.healthPath).toBe('/health');
+  });
+});
+
+describe('detectWorkload — LoRA training repo', () => {
+  it('classifies as training and estimates high VRAM for a large model', () => {
+    const dir = project({
+      'train.py': `
+from peft import LoraConfig
+base_model = "meta-llama/Llama-3.1-70B-Instruct"
+trainer = Trainer(model=model)
+trainer.train()
+`,
+      'config.yaml': 'base_model: meta-llama/Llama-3.1-70B-Instruct\nlora_r: 16\n',
+      'requirements.txt': 'peft\ntransformers\naccelerate\n',
+      'checkpoints/.gitkeep': '',
+    });
+    const report = detectWorkload(dir);
+    expect(report.workloadType).toBe('training');
+    expect(report.checkpoints).toContain('checkpoints/');
+    expect(report.models.some(m => m.includes('Llama-3.1-70B'))).toBe(true);
+    expect(report.vram).toBe('80+ GB');
+  });
+});
+
+describe('detectWorkload — ComfyUI-style project', () => {
+  it('classifies as image_gen from a workflow json without special-casing ComfyUI by name', () => {
+    const dir = project({
+      'workflow_api.json': JSON.stringify({ '1': { class_type: 'CheckpointLoaderSimple' } }),
+      'requirements.txt': 'torch\npillow\n',
+    });
+    const report = detectWorkload(dir);
+    expect(report.workloadType).toBe('image_gen');
+    expect(workloadTypeLabel(report.workloadType)).toMatch(/image generation/);
+  });
+});
+
+describe('detectWorkload — custom Docker image', () => {
+  it('detects the Dockerfile and exposed port instead of guessing a base image', () => {
+    const dir = project({
+      Dockerfile: `
+FROM python:3.11-slim
+COPY . /app
+EXPOSE 7860
+CMD ["python", "app.py"]
+`,
+      'app.py': `
+import gradio as gr
+demo = gr.Interface()
+demo.launch(server_port=7860)
+`,
+    });
+    const report = detectWorkload(dir);
+    expect(report.dockerfile).toBe('Dockerfile');
+    expect(report.image).toBeNull();
+    expect(report.ports).toContain(7860);
+    expect(report.workloadType).toBe('endpoint');
+  });
+});
+
+describe('detectWorkload — RunPod-style serverless handler job', () => {
+  it('classifies a handler-based job as an endpoint without naming any provider', () => {
+    const dir = project({
+      'rp_handler.py': `
+import runpod
+
+def handler(event):
+    return {"output": "ok"}
+
+runpod.serverless.start({"handler": handler})
+`,
+      'requirements.txt': 'runpod\n',
+    });
+    const report = detectWorkload(dir);
+    expect(report.command).toBe('python rp_handler.py');
+    expect(report.workloadType).toBe('endpoint');
+    // No provider name should leak into any user-visible field.
+    const serialized = JSON.stringify(report).toLowerCase();
+    expect(serialized).not.toContain('runpod.com');
+  });
+});
+
+describe('detectWorkload — batch image generation over an input directory', () => {
+  it('classifies as batch when the script iterates an input directory', () => {
+    const dir = project({
+      'generate.py': `
+import os
+for fname in os.listdir("input"):
+    process(fname)
+`,
+      'input/.gitkeep': '',
+      'output/.gitkeep': '',
+    });
+    const report = detectWorkload(dir);
+    expect(report.workloadType).toBe('batch');
+    expect(report.inputs).toContain('input/');
+    expect(report.outputs).toContain('output/');
+  });
+});
+
+describe('workloadTypeLabel', () => {
+  it('never returns a provider-specific label', () => {
+    for (const t of ['endpoint', 'training', 'image_gen', 'batch', 'custom', 'unknown']) {
+      expect(workloadTypeLabel(t)).not.toMatch(/runpod|vast|hyperstack/i);
+    }
+  });
+});

package/tests/job-progress-poll.test.js

@@ -0,0 +1,136 @@
+import { describe, it, expect, vi } from 'vitest';
+import { pollJobUntilTerminal, renderJobClosingBlock } from '../src/progress.js';
+
+const chalk = new Proxy({}, { get: () => (s) => s });
+const config = { apiKey: 'k', baseUrl: 'https://api.test' };
+
+function silenceStdout() {
+  return vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+}
+
+describe('pollJobUntilTerminal', () => {
+  it('returns immediately once the job reaches a terminal status', async () => {
+    const writeSpy = silenceStdout();
+    const detail = { job_id: 'job_1', status: 'completed', stage_label: 'Complete', health: 'completed' };
+    const callApi = vi.fn().mockResolvedValue(detail);
+
+    const result = await pollJobUntilTerminal(callApi, config, 'job_1', { chalk, maxMs: 60_000, pollMs: 1 });
+
+    expect(result.outcome).toBe('completed');
+    expect(result.detail).toBe(detail);
+    writeSpy.mockRestore();
+  });
+
+  it('surfaces progress fields (stage/current/total) while polling', async () => {
+    const writeSpy = silenceStdout();
+    const callApi = vi.fn()
+      .mockResolvedValueOnce({ job_id: 'job_2', status: 'running', stage_label: 'Generating images', progress_current: 3, progress_total: 10, progress_unit: 'images', health: 'progressing' })
+      .mockResolvedValueOnce({ job_id: 'job_2', status: 'completed', stage_label: 'Complete', health: 'completed' });
+
+    const result = await pollJobUntilTerminal(callApi, config, 'job_2', { chalk, maxMs: 60_000, pollMs: 1 });
+
+    expect(result.outcome).toBe('completed');
+    const output = writeSpy.mock.calls.map(c => c[0]).join('');
+    expect(output).toContain('3/10 images');
+    writeSpy.mockRestore();
+  });
+
+  it('does not swallow repeated poll failures silently — gives up and reports polling_failed', async () => {
+    const writeSpy = silenceStdout();
+    const callApi = vi.fn().mockRejectedValue(new Error('network down'));
+
+    const result = await pollJobUntilTerminal(callApi, config, 'job_3', { chalk, maxMs: 60_000, pollMs: 1 });
+
+    expect(result.outcome).toBe('polling_failed');
+    // Must have warned the user at least once instead of looping silently.
+    const output = writeSpy.mock.calls.map(c => c[0]).join('');
+    expect(output).toMatch(/Lost contact/i);
+    writeSpy.mockRestore();
+  });
+
+  it('announces a retry-on-a-different-route once, with teardown/billing status', async () => {
+    const writeSpy = silenceStdout();
+    const callApi = vi.fn()
+      .mockResolvedValueOnce({
+        job_id: 'job_retry', status: 'running', stage: 'retrying_different_route',
+        stage_label: 'Retrying on a different route', health: 'progressing',
+        progress_message: 'Retrying on a different route... attempt 2/2',
+        teardown_status: 'ok',
+      })
+      .mockResolvedValueOnce({
+        job_id: 'job_retry', status: 'completed', stage_label: 'Complete', health: 'completed',
+      });
+
+    const result = await pollJobUntilTerminal(callApi, config, 'job_retry', { chalk, maxMs: 60_000, pollMs: 1 });
+
+    expect(result.outcome).toBe('completed');
+    const output = writeSpy.mock.calls.map(c => c[0]).join('');
+    expect(output).toContain('Retrying on a different route... attempt 2/2');
+    expect(output).toContain('Previous attempt teardown: succeeded');
+    expect(output).toContain('Billing: stopped');
+    writeSpy.mockRestore();
+  });
+
+  it('recovers from transient poll failures once the API responds again', async () => {
+    const writeSpy = silenceStdout();
+    const callApi = vi.fn()
+      .mockRejectedValueOnce(new Error('timeout'))
+      .mockRejectedValueOnce(new Error('timeout'))
+      .mockResolvedValueOnce({ job_id: 'job_4', status: 'completed', stage_label: 'Complete', health: 'completed' });
+
+    const result = await pollJobUntilTerminal(callApi, config, 'job_4', { chalk, maxMs: 60_000, pollMs: 1 });
+
+    expect(result.outcome).toBe('completed');
+    writeSpy.mockRestore();
+  });
+});
+
+describe('renderJobClosingBlock', () => {
+  it('shows teardown/billing/logs/receipt for a completed job', () => {
+    const block = renderJobClosingBlock(chalk, {
+      job_id: 'job_5', status: 'completed', elapsed_seconds: 252,
+      charged_usd: 0.08, teardown_status: 'ok', billing_status: 'stopped',
+    }, 'rcpt-abc');
+
+    expect(block).toContain('Complete');
+    expect(block).toContain('Teardown: succeeded');
+    expect(block).toContain('Billing: stopped');
+    expect(block).toContain('badgr logs job_5');
+    expect(block).toContain('badgr receipts rcpt-abc');
+  });
+
+  it('shows failure class, stage, and next action for a failed job', () => {
+    const block = renderJobClosingBlock(chalk, {
+      job_id: 'job_6', status: 'failed', elapsed_seconds: 1112,
+      error: { code: 'comfy_health_failed', message: 'ComfyUI did not start within 10 minutes.' },
+      failure_class: 'health_check_failed', stage: 'comfy_waiting_for_health',
+      teardown_status: 'ok', billing_status: 'stopped',
+      next_action: 'Run `badgr logs <job_id>` or retry with a longer max-runtime.',
+    });
+
+    expect(block).toContain('Failed');
+    expect(block).toContain('Class: health_check_failed');
+    expect(block).toContain('Stage: comfy_waiting_for_health');
+    expect(block).toContain('Next:');
+  });
+
+  it('labels a runtime/spend cap failure as "Stopped — limit reached", not a crash', () => {
+    const block = renderJobClosingBlock(chalk, {
+      job_id: 'job_7', status: 'failed', elapsed_seconds: 545,
+      error: { code: 'max_runtime_reached', message: 'Job reached max runtime and was stopped. Billing ended.' },
+      failure_class: 'runtime_cap_reached',
+      teardown_status: 'ok', billing_status: 'stopped',
+    });
+
+    expect(block).toContain('Stopped — limit reached');
+  });
+
+  it('shows cancelled block distinctly from failed', () => {
+    const block = renderJobClosingBlock(chalk, {
+      job_id: 'job_8', status: 'canceled', elapsed_seconds: 164,
+      teardown_status: 'ok', billing_status: 'stopped',
+    });
+
+    expect(block).toContain('Cancelled by user');
+  });
+});

package/tests/productized-runners.test.js

@@ -131,6 +131,13 @@ describe('BLESSED_COMFY_WORKFLOWS catalog', () => {
     expect(wf.gpu_type).toBe('RTX_4090');
     expect(wf.output_type).toBe('images');
   });
+
+  it('has flux-basic with gpu_type and output_type', () => {
+    const wf = BLESSED_COMFY_WORKFLOWS['flux-basic'];
+    expect(wf).toBeDefined();
+    expect(wf.gpu_type).toBe('RTX_4090');
+    expect(wf.output_type).toBe('images');
+  });
 });
 
 // ── parseServeArgs alias recognition ─────────────────────────────────────────

package/tests/run-lifecycle.test.js

@@ -15,7 +15,7 @@
  *   - Receipt explains state   → status, exitCode, failureType, runtimeSeconds, finalCost
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { runCommand } from '../src/commands/run.js';
+import { runCommand, parseRunArgs } from '../src/commands/run.js';
 
 // ── Module mocks ──────────────────────────────────────────────────────────────
 
@@ -222,6 +222,26 @@ describe('container fails to start', () => {
 
     expect(process.exitCode).toBe(1);
   });
+
+  it('prints the backend failure_class/next_action using the same vocabulary as the job API', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeDep({ status: 'provisioning' }))
+      .mockResolvedValueOnce({
+        status: 'failed',
+        failure_class: 'container_start_failed',
+        next_action: 'Check the image and command, then retry.',
+      });
+    const logs = [];
+    const origError = console.error;
+    console.error = (...args) => { logs.push(args.join(' ')); origError(...args); };
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
+    await vi.advanceTimersByTimeAsync(4000);
+    await p;
+    console.error = origError;
+
+    expect(logs.some(l => l.includes('Class: container_start_failed'))).toBe(true);
+    expect(logs.some(l => l.includes('Next: Check the image and command, then retry.'))).toBe(true);
+  });
 });
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -543,3 +563,93 @@ describe('--dry-run', () => {
     expect(api.callApi).not.toHaveBeenCalled();
   });
 });
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 13. Progress-loss handling — --output / --checkpoint / --retry-safe / --resume-cmd
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('--output / --checkpoint / --retry-safe / --resume-cmd', () => {
+  it('parseRunArgs parses all four flags', () => {
+    const { flags } = parseRunArgs([
+      '--output', './outputs', '--checkpoint', './checkpoints', '--retry-safe',
+      '--resume-cmd', 'python train.py --resume ./checkpoints/latest',
+      '--max-cost', '5', '--', 'python', 'train.py',
+    ]);
+    expect(flags.output).toBe('./outputs');
+    expect(flags.checkpoint).toBe('./checkpoints');
+    expect(flags.retrySafe).toBe(true);
+    expect(flags.resumeCmd).toBe('python train.py --resume ./checkpoints/latest');
+  });
+
+  it('wires --output/--checkpoint/--retry-safe into the job env as BADGR_* vars', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeDep())
+      .mockResolvedValueOnce({ status: 'completed', exit_code: 0 })
+      .mockResolvedValueOnce({ logs: [] });
+    const p = runCommand(config, [
+      '--output', './outputs', '--checkpoint', './checkpoints', '--retry-safe',
+      '--max-cost', '5', '--', 'python', 'train.py',
+    ], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    const postRunBody = api.callApi.mock.calls[0][1].body;
+    expect(postRunBody.env).toEqual(expect.objectContaining({
+      BADGR_OUTPUT_DIR: './outputs',
+      BADGR_CHECKPOINT_DIR: './checkpoints',
+      BADGR_RETRY_SAFE: '1',
+    }));
+  });
+
+  it('explicit --env overrides the BADGR_* convention var for the same key', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeDep())
+      .mockResolvedValueOnce({ status: 'completed', exit_code: 0 })
+      .mockResolvedValueOnce({ logs: [] });
+    const p = runCommand(config, [
+      '--output', './outputs', '--env', 'BADGR_OUTPUT_DIR=./custom-outputs',
+      '--max-cost', '5', '--', 'python', 'train.py',
+    ], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    const postRunBody = api.callApi.mock.calls[0][1].body;
+    expect(postRunBody.env.BADGR_OUTPUT_DIR).toBe('./custom-outputs');
+  });
+
+  it('prints the --resume-cmd hint when the job fails', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeDep())
+      .mockResolvedValueOnce({ status: 'failed', exit_code: 1 })
+      .mockResolvedValueOnce({ logs: [] });
+    const logs = [];
+    const captureChalk = { bold: s => s, dim: s => s, red: s => s, yellow: s => s, green: s => s, cyan: s => s };
+    const origLog = console.log;
+    console.log = (...args) => { logs.push(args.join(' ')); origLog(...args); };
+    const p = runCommand(config, [
+      '--resume-cmd', 'python train.py --resume ./checkpoints/latest',
+      '--max-cost', '5', '--', 'python', 'train.py',
+    ], captureChalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+    console.log = origLog;
+
+    expect(logs.some(l => l.includes('python train.py --resume ./checkpoints/latest'))).toBe(true);
+  });
+
+  it('does not print a Resume line when --resume-cmd was not given', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeDep())
+      .mockResolvedValueOnce({ status: 'failed', exit_code: 1 })
+      .mockResolvedValueOnce({ logs: [] });
+    const logs = [];
+    const origLog = console.log;
+    console.log = (...args) => { logs.push(args.join(' ')); origLog(...args); };
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+    console.log = origLog;
+
+    expect(logs.some(l => l.includes('Resume:'))).toBe(false);
+  });
+});

package/tests/serve-apps.test.js

@@ -0,0 +1,189 @@
+/**
+ * `badgr serve openwebui` — a chat UI that connects to a model endpoint.
+ *
+ * Reuses a running vLLM endpoint for the requested model if one exists, or
+ * launches one first, then wires OPENAI_API_BASE_URL/OPENAI_API_KEY to it —
+ * via the same serveCommand/template machinery `badgr serve template <name>`
+ * already uses. No new provisioning path.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { serveCommand } from '../src/commands/serve.js';
+
+vi.mock('../src/api.js', () => ({
+  callApi:             vi.fn(),
+  terminateDeployment: vi.fn().mockResolvedValue({}),
+  listDeployments:     vi.fn().mockResolvedValue({ deployments: [], count: 0 }),
+}));
+
+vi.mock('../src/store.js', () => ({
+  addDeployment:        vi.fn(),
+  addReceipt:           vi.fn(),
+  updateReceipt:        vi.fn(),
+  generateReceiptId:    vi.fn(() => 'rcpt-app-001'),
+  generateDeploymentId: vi.fn(() => 'dep-app-001'),
+  listDeployments:      vi.fn(() => []),
+  listReceipts:         vi.fn(() => []),
+  findDeployment:       vi.fn(() => null),
+  updateDeployment:     vi.fn(),
+  removeDeployment:     vi.fn(),
+}));
+
+import * as api   from '../src/api.js';
+import * as store from '../src/store.js';
+
+const config = { apiKey: 'sk-test', baseUrl: 'https://api.test/v1' };
+const chalk = {
+  bold: s => s, dim: s => s, red: s => s, yellow: s => s, green: s => s, cyan: s => s,
+};
+
+function makeServeDep(overrides = {}) {
+  return {
+    deployment_id: 'dep-app-001',
+    status:        'running',
+    gpu_type:      'RTX_4090',
+    gpu_count:     1,
+    cost_per_hour: 0.50,
+    provider:      'runpod',
+    receipt_id:    'rcpt-app-001',
+    tier:          '1',
+    endpoint_url:  'https://dep-app-001.aibadgr.com/v1',
+    ...overrides,
+  };
+}
+
+// Queues one POST /serve → status → ready cycle onto api.callApi.
+function queueServeCycle(depOverrides = {}) {
+  api.callApi
+    .mockResolvedValueOnce(makeServeDep(depOverrides))
+    .mockResolvedValueOnce({ status: 'running' })
+    .mockResolvedValueOnce({ status: 'running', endpoint_ready: true });
+}
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  process.exitCode = undefined;
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+  vi.spyOn(console, 'error').mockImplementation(() => {});
+  vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+  vi.clearAllMocks();
+  store.generateReceiptId.mockReturnValue('rcpt-app-001');
+  api.terminateDeployment.mockResolvedValue({});
+  api.listDeployments.mockResolvedValue({ deployments: [], count: 0 });
+});
+
+describe('badgr serve openwebui — reuses a running vLLM endpoint', () => {
+  it('connects to an existing endpoint instead of launching a second one', async () => {
+    api.listDeployments.mockResolvedValueOnce({
+      deployments: [{
+        status: 'running',
+        workload_type: 'endpoint',
+        model: 'Qwen/Qwen2.5-7B-Instruct',
+        endpoint_url: 'https://dep-existing.aibadgr.com/v1',
+      }],
+      count: 1,
+    });
+    queueServeCycle(); // only one cycle — openwebui itself
+
+    const p = serveCommand(config, ['openwebui', '--model', 'qwen-7b', '--max-cost', '5'], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    expect(api.callApi.mock.calls.length).toBe(3); // no second /serve for vLLM
+    const [, opts] = api.callApi.mock.calls[0];
+    expect(opts.body.image).toBe('ghcr.io/open-webui/open-webui:main');
+    expect(opts.body.env.OPENAI_API_BASE_URL).toBe('https://dep-existing.aibadgr.com/v1');
+    expect(process.exitCode).toBeFalsy();
+  });
+});
+
+describe('badgr serve openwebui — launches vLLM first when none is running', () => {
+  it('serves vLLM (warning about the separate budget), then Open WebUI wired to the new endpoint', async () => {
+    // listDeployments is called 4 times: pre-launch discovery (none) →
+    // vLLM's own duplicate check (none) → post-launch discovery (found) →
+    // Open WebUI's own duplicate check (none — no image field to match).
+    api.listDeployments
+      .mockResolvedValueOnce({ deployments: [], count: 0 })
+      .mockResolvedValueOnce({ deployments: [], count: 0 })
+      .mockResolvedValueOnce({
+        deployments: [{
+          deployment_id: 'dep-vllm-new',
+          status: 'running',
+          workload_type: 'endpoint',
+          model: 'Qwen/Qwen2.5-7B-Instruct',
+          endpoint_url: 'https://dep-new.aibadgr.com/v1',
+        }],
+        count: 1,
+      });
+    queueServeCycle({ model: 'Qwen/Qwen2.5-7B-Instruct' }); // vLLM launch
+    queueServeCycle();                                       // Open WebUI launch
+
+    const p = serveCommand(config, ['openwebui', '--model', 'qwen-7b', '--max-cost', '5'], chalk);
+    await vi.advanceTimersByTimeAsync(10_000);
+    await p;
+
+    expect(api.callApi.mock.calls.length).toBe(6);
+    const [, vllmOpts] = api.callApi.mock.calls[0];
+    expect(vllmOpts.body.model).toBe('Qwen/Qwen2.5-7B-Instruct');
+    const [, webuiOpts] = api.callApi.mock.calls[3];
+    expect(webuiOpts.body.image).toBe('ghcr.io/open-webui/open-webui:main');
+    expect(webuiOpts.body.env.OPENAI_API_BASE_URL).toBe('https://dep-new.aibadgr.com/v1');
+    expect(process.exitCode).toBeFalsy();
+
+    // --max-cost applies to both the auto-launched vLLM and Open WebUI
+    // separately — the CLI must say so rather than double-spend silently.
+    const logged = console.log.mock.calls.flat().join('\n');
+    expect(logged).toContain('own --max-cost $5 cap');
+    expect(logged).toContain('Total possible spend across both deployments: ~$10.00');
+  });
+
+  it('prints a badgr down hint for the auto-launched vLLM deployment if Open WebUI then fails', async () => {
+    api.listDeployments
+      .mockResolvedValueOnce({ deployments: [], count: 0 })  // pre-launch discovery
+      .mockResolvedValueOnce({ deployments: [], count: 0 })  // vLLM's own dup-check
+      .mockResolvedValueOnce({                                // post-launch discovery — vLLM is up
+        deployments: [{
+          deployment_id: 'dep-vllm-999',
+          status: 'running',
+          workload_type: 'endpoint',
+          model: 'Qwen/Qwen2.5-7B-Instruct',
+          endpoint_url: 'https://dep-vllm-999.aibadgr.com/v1',
+        }],
+        count: 1,
+      })
+      .mockResolvedValueOnce({ deployments: [], count: 0 }); // Open WebUI's own dup-check
+
+    queueServeCycle({ model: 'Qwen/Qwen2.5-7B-Instruct' }); // vLLM launch succeeds
+    // Open WebUI's own POST /serve "succeeds" but hands back no endpoint URL —
+    // serveCommand's own no-endpoint-url guard fires and sets exitCode = 1.
+    api.callApi.mockResolvedValueOnce(makeServeDep({ endpoint_url: undefined }));
+
+    const p = serveCommand(config, ['openwebui', '--model', 'qwen-7b', '--max-cost', '5'], chalk);
+    await vi.advanceTimersByTimeAsync(10_000);
+    await p;
+
+    expect(process.exitCode).toBe(1);
+    const logged = console.error.mock.calls.flat().join('\n');
+    expect(logged).toContain('badgr down dep-vllm-999');
+  });
+});
+
+describe('badgr serve openwebui --connect', () => {
+  it('skips vLLM discovery/launch entirely and wires the given URL', async () => {
+    queueServeCycle();
+    const p = serveCommand(
+      config,
+      ['openwebui', '--connect', 'https://my-server.example.com/v1', '--max-cost', '5'],
+      chalk,
+    );
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    // Only the one serve cycle ran (Open WebUI itself) — no vLLM discovery/launch.
+    expect(api.callApi.mock.calls.length).toBe(3);
+    const [, opts] = api.callApi.mock.calls[0];
+    expect(opts.body.env.OPENAI_API_BASE_URL).toBe('https://my-server.example.com/v1');
+
+    const logged = console.log.mock.calls.flat().join('\n');
+    expect(logged).not.toContain('needs a model endpoint behind it');
+  });
+});