badgr-cli 1.0.40 → 1.0.42

package/tests/serve-lifecycle.test.js

@@ -663,3 +663,117 @@ describe('llama.cpp E2E smoke — tiny GGUF (ggml-org/tiny-llamas)', () => {
     expect(process.exitCode).toBeFalsy();
   });
 });
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 13. --task routing: transcribe and image use /health; embed uses /models
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('--task routing for managed runtimes', () => {
+  it('--task transcribe polls /health instead of /models', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeServeDep({ model: 'large-v3' }))  // POST /serve
+      .mockResolvedValueOnce({ status: 'running' });                // pre-health dep check
+
+    const fetchedUrls = [];
+    global.fetch = vi.fn().mockImplementation((url) => {
+      fetchedUrls.push(url);
+      return Promise.resolve({ ok: true, status: 200 });
+    });
+
+    const p = serveCommand(
+      config,
+      ['large-v3', '--task', 'transcribe', '--max-cost', '5'],
+      chalk,
+    );
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    expect(fetchedUrls.some(u => u.includes('/health'))).toBe(true);
+    expect(fetchedUrls.some(u => u.endsWith('/models'))).toBe(false);
+    expect(process.exitCode).toBeFalsy();
+  });
+
+  it('--task transcribe sends task field to backend', async () => {
+    api.callApi.mockResolvedValueOnce(makeServeDep({ model: 'large-v3' }));
+    global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200 });
+
+    const p = serveCommand(
+      config,
+      ['large-v3', '--task', 'transcribe', '--max-cost', '5', '--no-wait'],
+      chalk,
+    );
+    await vi.advanceTimersByTimeAsync(100);
+    await p;
+
+    const body = api.callApi.mock.calls[0][1].body;
+    expect(body.task).toBe('transcribe');
+    expect(body.model).toBe('large-v3');
+    expect(process.exitCode).toBeFalsy();
+  });
+
+  it('--task image polls /health instead of /models', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeServeDep({ model: 'black-forest-labs/FLUX.1-schnell' }))
+      .mockResolvedValueOnce({ status: 'running' });
+
+    const fetchedUrls = [];
+    global.fetch = vi.fn().mockImplementation((url) => {
+      fetchedUrls.push(url);
+      return Promise.resolve({ ok: true, status: 200 });
+    });
+
+    const p = serveCommand(
+      config,
+      ['black-forest-labs/FLUX.1-schnell', '--task', 'image', '--max-cost', '10'],
+      chalk,
+    );
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    expect(fetchedUrls.some(u => u.includes('/health'))).toBe(true);
+    expect(fetchedUrls.some(u => u.endsWith('/models'))).toBe(false);
+    expect(process.exitCode).toBeFalsy();
+  });
+
+  it('--task image sends task field to backend', async () => {
+    api.callApi.mockResolvedValueOnce(makeServeDep({ model: 'black-forest-labs/FLUX.1-schnell' }));
+    global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200 });
+
+    const p = serveCommand(
+      config,
+      ['black-forest-labs/FLUX.1-schnell', '--task', 'image', '--max-cost', '10', '--no-wait'],
+      chalk,
+    );
+    await vi.advanceTimersByTimeAsync(100);
+    await p;
+
+    const body = api.callApi.mock.calls[0][1].body;
+    expect(body.task).toBe('image');
+    expect(body.model).toBe('black-forest-labs/FLUX.1-schnell');
+    expect(process.exitCode).toBeFalsy();
+  });
+
+  it('--task embed still polls /models (vLLM path)', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeServeDep({ model: 'BAAI/bge-large-en-v1.5' }))
+      .mockResolvedValueOnce({ status: 'running' });
+
+    const fetchedUrls = [];
+    global.fetch = vi.fn().mockImplementation((url) => {
+      fetchedUrls.push(url);
+      return Promise.resolve({ ok: true, status: 200 });
+    });
+
+    const p = serveCommand(
+      config,
+      ['BAAI/bge-large-en-v1.5', '--task', 'embed', '--max-cost', '5'],
+      chalk,
+    );
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    expect(fetchedUrls.some(u => u.endsWith('/models'))).toBe(true);
+    expect(fetchedUrls.some(u => u.includes('/health'))).toBe(false);
+    expect(process.exitCode).toBeFalsy();
+  });
+});

package/tests/template.test.js

@@ -105,14 +105,14 @@ afterEach(() => {
 
 describe('TEMPLATES catalog', () => {
   const EXPECTED_NAMES = [
-    'comfyui', 'axolotl', 'unsloth', 'vllm', 'llama-cpp',
+    'comfyui', 'axolotl', 'batch-inference', 'unsloth', 'vllm', 'llama-cpp',
     'invokeai', 'kohya-ss', 'text-gen-webui', 'sglang', 'tgi',
     'auto1111', 'forge', 'nerfstudio', 'openfold', 'blender-render',
     'openmm', 'gromacs', 'lammps', 'diffusers', 'torchtune',
   ];
 
-  it('contains exactly 20 templates', () => {
-    expect(TEMPLATES).toHaveLength(20);
+  it('contains exactly 21 templates', () => {
+    expect(TEMPLATES).toHaveLength(21);
   });
 
   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(20);
+    expect(Object.keys(TEMPLATE_MAP)).toHaveLength(21);
   });
 });
 

package/tests/upload.test.js

@@ -0,0 +1,79 @@
+/**
+ * badgr run — local-project upload flow (regression).
+ *
+ * Guards the bug where `_uploadCodeZip` imported `node-fetch` (an undeclared
+ * dependency) and the `form-data` package: both broke `badgr run . --cmd …`
+ * with "Cannot find package 'form-data'". The upload now uses Node's built-in
+ * FormData / Blob / fetch (Node >=18), so the CLI needs no extra HTTP deps.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { _uploadCodeZip } from '../src/commands/run.js';
+
+const chalk = { dim: (s) => s, bold: (s) => s, red: (s) => s };
+
+let tmpDir;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'badgr-upload-test-'));
+  fs.writeFileSync(path.join(tmpDir, 'hello.py'), "print('hi')\n");
+  vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe('_uploadCodeZip (local-project flow)', () => {
+  it('uses built-in fetch + FormData and returns the backend code_uri', async () => {
+    // Built-ins must exist in the supported Node runtime — if these are
+    // undefined the upload would fall back to the missing node-fetch/form-data.
+    expect(typeof fetch).toBe('function');
+    expect(typeof FormData).toBe('function');
+    expect(typeof Blob).toBe('function');
+
+    let captured = null;
+    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockImplementation(async (url, opts) => {
+      captured = { url, opts };
+      return { ok: true, json: async () => ({ code_uri: 'https://aibadgr.com/v1/uploads/up_x/download?token=t' }) };
+    });
+
+    const config = { apiKey: 'sk-test', baseUrl: 'https://aibadgr.com/v1' };
+    const codeUri = await _uploadCodeZip(config, tmpDir, chalk);
+
+    expect(codeUri).toBe('https://aibadgr.com/v1/uploads/up_x/download?token=t');
+    expect(fetchSpy).toHaveBeenCalledTimes(1);
+    expect(captured.url).toBe('https://aibadgr.com/v1/uploads');
+    expect(captured.opts.method).toBe('POST');
+    expect(captured.opts.body).toBeInstanceOf(FormData);
+    expect(captured.opts.body.get('file')).toBeInstanceOf(Blob);
+    expect(captured.opts.headers.Authorization).toBe('Bearer sk-test');
+    // fetch derives the multipart Content-Type/boundary from the FormData body —
+    // the CLI must NOT set it manually (that was the form-data getHeaders() path).
+    expect(captured.opts.headers['Content-Type']).toBeUndefined();
+  });
+
+  it('throws a clear error and still deletes the temp zip when upload fails', async () => {
+    const listZips = () =>
+      new Set(fs.readdirSync(os.tmpdir()).filter(f => f.startsWith('badgr-upload-') && f.endsWith('.zip')));
+    const before = listZips();
+
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: false,
+      status: 500,
+      statusText: 'Internal Server Error',
+      text: async () => 'boom',
+    });
+
+    const config = { apiKey: 'sk-test', baseUrl: 'https://aibadgr.com/v1' };
+    await expect(_uploadCodeZip(config, tmpDir, chalk)).rejects.toThrow(/Upload failed: 500/);
+
+    // The temp zip created by THIS call must be cleaned up even on failure.
+    const after = listZips();
+    const newLeftovers = [...after].filter(f => !before.has(f));
+    expect(newLeftovers).toEqual([]);
+  });
+});