badgr-cli 1.0.44 → 1.0.45

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');
+  });
+});

package/tests/serve-lifecycle.test.js

@@ -239,6 +239,27 @@ describe('deployment fails during startup', () => {
     const errLines = console.error.mock.calls.flat().join('\n');
     expect(errLines).toContain('likely an OOM');
   });
+
+  it('prints failure_class/next_action from the backend using the shared vocabulary', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeServeDep())
+      .mockResolvedValueOnce({ status: 'running' })
+      .mockResolvedValueOnce({
+        status: 'failed',
+        error: 'pod_exited',
+        fix_hint: 'The pod stopped running before the endpoint ever responded.',
+        failure_class: 'container_start_failed',
+        next_action: 'Check the image and command, then retry.',
+      });
+
+    const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--max-cost', '5'], chalk);
+    await vi.advanceTimersByTimeAsync(10000);
+    await p;
+
+    const errLines = console.error.mock.calls.flat().join('\n');
+    expect(errLines).toContain('Class: container_start_failed');
+    expect(errLines).toContain('Next: Check the image and command, then retry.');
+  });
 });
 
 // ─────────────────────────────────────────────────────────────────────────────

package/tests/store.test.js

@@ -5,7 +5,7 @@ import { rmSync, existsSync } from 'fs';
 import {
   loadStore, saveStore,
   addDeployment, updateDeployment, removeDeployment, findDeployment, listDeployments,
-  addReceipt, updateReceipt, listReceipts,
+  addReceipt, updateReceipt, listReceipts, findReceipt,
   generateDeploymentId, generateReceiptId,
 } from '../src/store.js';
 
@@ -125,6 +125,27 @@ describe('addReceipt / listReceipts', () => {
   });
 });
 
+describe('findReceipt', () => {
+  // comfy.batch / train.lora mint a local rcpt- id that points at a job_id —
+  // `badgr receipts <id>` needs to resolve either the receipt id itself or
+  // the job_id back to the same local record (see receipts.js).
+  it('finds a receipt by its own receiptId', () => {
+    addReceipt({ receiptId: 'rcpt-1', type: 'comfy.batch', job_id: 'job_abc' }, file);
+    const found = findReceipt('rcpt-1', file);
+    expect(found?.job_id).toBe('job_abc');
+  });
+
+  it('finds a receipt by job_id', () => {
+    addReceipt({ receiptId: 'rcpt-2', type: 'train.lora', job_id: 'job_def' }, file);
+    const found = findReceipt('job_def', file);
+    expect(found?.receiptId).toBe('rcpt-2');
+  });
+
+  it('returns null when nothing matches', () => {
+    expect(findReceipt('nope', file)).toBeNull();
+  });
+});
+
 describe('updateReceipt', () => {
   it('merges updates into an existing receipt', () => {
     addReceipt({ receiptId: 'r-upd', action: 'badgr run', status: 'running' }, file);

package/tests/template.test.js

@@ -105,14 +105,14 @@ afterEach(() => {
 
 describe('TEMPLATES catalog', () => {
   const EXPECTED_NAMES = [
-    'comfyui', 'axolotl', 'batch-inference', 'unsloth', 'vllm', 'llama-cpp',
+    'comfyui', 'axolotl', 'batch-inference', 'unsloth', 'vllm', 'openwebui', 'llama-cpp',
     'invokeai', 'kohya-ss', 'text-gen-webui', 'sglang', 'tgi',
     'auto1111', 'forge', 'nerfstudio', 'openfold', 'blender-render',
     'openmm', 'gromacs', 'lammps', 'diffusers', 'torchtune',
   ];
 
-  it('contains exactly 21 templates', () => {
-    expect(TEMPLATES).toHaveLength(21);
+  it('contains exactly 22 templates', () => {
+    expect(TEMPLATES).toHaveLength(22);
   });
 
   it('contains all expected template names', () => {
@@ -180,7 +180,7 @@ describe('TEMPLATES catalog', () => {
     for (const [k, t] of Object.entries(TEMPLATE_MAP)) {
       expect(k).toBe(t.name);
     }
-    expect(Object.keys(TEMPLATE_MAP)).toHaveLength(21);
+    expect(Object.keys(TEMPLATE_MAP)).toHaveLength(22);
   });
 });
 

package/tests/workload-templates.test.js

@@ -300,6 +300,28 @@ describe('comfyuiCommand', () => {
     }));
     expect(process.exitCode).toBe(1);
   });
+
+  it('prints failure_class/next_action from the backend using the shared vocabulary', async () => {
+    fs.existsSync.mockReturnValue(true);
+    fs.readFileSync.mockReturnValue(JSON.stringify({ '1': {} }));
+    fallback.callWithFallback.mockResolvedValue(makeServeDep());
+
+    api.callApi.mockResolvedValue({
+      status: 'failed',
+      error: 'OOM',
+      failure_class: 'container_start_failed',
+      next_action: 'Check the image and command, then retry.',
+    });
+    global.fetch = vi.fn().mockRejectedValue(new Error('Connection refused'));
+
+    const p = comfyuiCommand(config, ['wf.json', '--max-cost', '5'], chalk);
+    await vi.advanceTimersByTimeAsync(10000);
+    await p;
+
+    const errLines = console.error.mock.calls.flat().join('\n');
+    expect(errLines).toContain('Class: container_start_failed');
+    expect(errLines).toContain('Next: Check the image and command, then retry.');
+  });
 });
 
 // ─────────────────────────────────────────────────────────────────────────────