badgr-cli 1.0.36 → 1.0.38

package/src/commands/template.js

@@ -0,0 +1,119 @@
+/**
+ * badgr template list
+ * badgr template info <name>
+ *
+ * Provider-neutral workload templates for common ML frameworks.
+ * Launching routes through `badgr serve template <name>` / `badgr run template <name>`.
+ */
+import { TEMPLATES, TEMPLATE_MAP, buildTemplateFlags, parseTemplateOverrides } from '../catalog.js';
+import { serveCommand } from './serve.js';
+import { runCommand }   from './run.js';
+
+// Re-export for tests
+export { TEMPLATES };
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+function col(s, w) {
+  return String(s ?? '').padEnd(w).slice(0, w);
+}
+
+function printList(chalk) {
+  console.log(chalk.bold('\nAvailable templates\n'));
+  console.log(`  ${'NAME'.padEnd(18)}  ${'TYPE'.padEnd(8)}  ${'GPU'.padEnd(10)}  DESCRIPTION`);
+  console.log(`  ${'─'.repeat(18)}  ${'─'.repeat(8)}  ${'─'.repeat(10)}  ${'─'.repeat(44)}`);
+  for (const t of TEMPLATES) {
+    const type = t.type === 'endpoint' ? chalk.cyan(col(t.type, 8)) : chalk.yellow(col(t.type, 8));
+    console.log(`  ${chalk.bold(col(t.name, 18))}  ${type}  ${col(t.gpu, 10)}  ${t.description}`);
+  }
+  console.log();
+  console.log(chalk.dim('  badgr template info <name>               Show full template details'));
+  console.log(chalk.dim('  badgr serve template <name> [flags]      Launch an endpoint template'));
+  console.log(chalk.dim('  badgr run   template <name> [flags]      Launch a job template'));
+  console.log();
+}
+
+function printInfo(t, chalk) {
+  console.log(chalk.bold(`\n${t.title}\n`));
+  console.log(`  ${chalk.bold('Name:')}         ${t.name}`);
+  console.log(`  ${chalk.bold('Description:')} ${t.description}`);
+  console.log(`  ${chalk.bold('Type:')}         ${t.type}`);
+  console.log(`  ${chalk.bold('Image:')}        ${t.image}`);
+  console.log(`  ${chalk.bold('GPU:')}          ${t.gpu} × ${t.gpu_count}  (${t.min_vram_gb}+ GB VRAM)`);
+  if (t.port)        console.log(`  ${chalk.bold('Port:')}         ${t.port}`);
+  if (t.health_path) console.log(`  ${chalk.bold('Health:')}       ${t.health_path}`);
+  if (t.env && Object.keys(t.env).length > 0) {
+    console.log(`  ${chalk.bold('Env defaults:')}`);
+    for (const [k, v] of Object.entries(t.env)) {
+      console.log(`    ${chalk.cyan(k)}=${chalk.dim(v)}`);
+    }
+  }
+  if (t.command) {
+    console.log(`  ${chalk.bold('Command:')}      ${t.command.join(' ')}`);
+  }
+  if (t.notes?.length) {
+    console.log(`\n  ${chalk.bold('Notes:')}`);
+    for (const n of t.notes) console.log(`    ${chalk.dim(n)}`);
+  }
+  console.log();
+  const verb = t.type === 'job' ? 'run' : 'serve';
+  console.log(`  ${chalk.bold('Launch:')}`);
+  console.log(chalk.dim(`    badgr ${verb} template ${t.name} --max-cost <N>`));
+  console.log();
+}
+
+// ── Main command ───────────────────────────────────────────────────────────────
+
+export async function templateCommand(config, args, chalk) {
+  const [sub, name, ...rest] = args;
+
+  if (!sub || sub === 'list' || sub === '--help' || sub === '-h') {
+    printList(chalk);
+    return;
+  }
+
+  if (sub === 'info') {
+    if (!name) {
+      console.error(chalk.red('  Usage: badgr template info <name>\n'));
+      printList(chalk);
+      process.exitCode = 1;
+      return;
+    }
+    const t = TEMPLATE_MAP[name];
+    if (!t) {
+      console.error(chalk.red(`\n  Unknown template: ${name}\n`));
+      console.error(chalk.dim('  Run `badgr template list` to see available templates.'));
+      process.exitCode = 1;
+      return;
+    }
+    printInfo(t, chalk);
+    return;
+  }
+
+  // `badgr template run <name>` — kept as a convenience alias
+  if (sub === 'run') {
+    if (!name) {
+      console.error(chalk.red('  Usage: badgr template run <name> [--max-cost N] [--env K=V]\n'));
+      printList(chalk);
+      process.exitCode = 1;
+      return;
+    }
+    const t = TEMPLATE_MAP[name];
+    if (!t) {
+      console.error(chalk.red(`\n  Unknown template: ${name}\n`));
+      console.error(chalk.dim('  Run `badgr template list` to see available templates.'));
+      process.exitCode = 1;
+      return;
+    }
+    const overrides = parseTemplateOverrides(rest);
+    const flags = buildTemplateFlags(t, overrides);
+    console.log(chalk.dim(`  Template: ${t.title}  →  badgr ${t.type === 'job' ? 'run' : 'serve'} ${flags.join(' ')}\n`));
+    return t.type === 'job'
+      ? runCommand(config, flags, chalk)
+      : serveCommand(config, flags, chalk);
+  }
+
+  console.error(chalk.red(`\n  Unknown subcommand: badgr template ${sub}\n`));
+  console.error(chalk.dim('  Subcommands: list, info <name>'));
+  process.exitCode = 1;
+}

package/tests/down.test.js

@@ -0,0 +1,128 @@
+/**
+ * badgr down — receipt display and runtime formatting tests
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { downCommand } from '../src/commands/down.js';
+
+vi.mock('../src/api.js', () => ({
+  terminateDeployment: vi.fn(),
+  listDeployments:     vi.fn(),
+}));
+
+vi.mock('../src/store.js', () => ({
+  findDeployment:    vi.fn(() => null),
+  removeDeployment:  vi.fn(),
+  addReceipt:        vi.fn(),
+  generateReceiptId: vi.fn(() => 'rcpt-test-001'),
+}));
+
+vi.mock('../src/config.js', () => ({
+  requireApiKey: 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 makeStoppedDep(runtimeSeconds, costPerHour = 1.00) {
+  const now = Date.now() / 1000;
+  return {
+    deployment_id: 'dep-test-001',
+    gpu_type:      'L40S',
+    cost_per_hour: costPerHour,
+    stopped_at:    now,
+    started_at:    now - runtimeSeconds,
+  };
+}
+
+beforeEach(() => {
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+  vi.spyOn(console, 'error').mockImplementation(() => {});
+  vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+  vi.resetAllMocks();
+  store.findDeployment.mockReturnValue(null);
+  store.generateReceiptId.mockReturnValue('rcpt-test-001');
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('runtime display formatting', () => {
+  it('shows minutes only for short runs (< 1h)', async () => {
+    api.terminateDeployment.mockResolvedValue(makeStoppedDep(27 * 60, 0.34));
+    const lines = [];
+    console.log.mockImplementation((...args) => lines.push(args.join(' ')));
+
+    await downCommand(config, ['dep-test-001'], chalk);
+
+    const runtimeLine = lines.find(l => l.includes('Runtime:'));
+    expect(runtimeLine).toMatch(/27m/);
+    expect(runtimeLine).not.toMatch(/\dh/);
+  });
+
+  it('shows hours and minutes for runs >= 1h', async () => {
+    api.terminateDeployment.mockResolvedValue(makeStoppedDep(4091 * 60, 1.00));
+    const lines = [];
+    console.log.mockImplementation((...args) => lines.push(args.join(' ')));
+
+    await downCommand(config, ['dep-test-001'], chalk);
+
+    const runtimeLine = lines.find(l => l.includes('Runtime:'));
+    expect(runtimeLine).toMatch(/2d 20h 11m/);
+    expect(runtimeLine).not.toMatch(/4091m/);
+  });
+
+  it('shows days, hours, minutes for multi-day runs', async () => {
+    api.terminateDeployment.mockResolvedValue(makeStoppedDep(5722 * 60, 0.46));
+    const lines = [];
+    console.log.mockImplementation((...args) => lines.push(args.join(' ')));
+
+    await downCommand(config, ['dep-test-001'], chalk);
+
+    const runtimeLine = lines.find(l => l.includes('Runtime:'));
+    expect(runtimeLine).toMatch(/3d 23h 22m/);
+    expect(runtimeLine).not.toMatch(/5722m/);
+  });
+});
+
+describe('receipt is recorded', () => {
+  it('adds a receipt with correct fields on stop', async () => {
+    api.terminateDeployment.mockResolvedValue(makeStoppedDep(27 * 60, 0.34));
+
+    await downCommand(config, ['dep-test-001'], chalk);
+
+    expect(store.addReceipt).toHaveBeenCalledWith(expect.objectContaining({
+      receiptId:    'rcpt-test-001',
+      deploymentId: 'dep-test-001',
+      gpu:          'L40S',
+      status:       'terminated',
+    }));
+    const call = store.addReceipt.mock.calls[0][0];
+    expect(call.runtimeSeconds).toBeCloseTo(27 * 60, -1);
+    expect(call.finalCost).toBeGreaterThan(0);
+  });
+});
+
+describe('error handling', () => {
+  it('prints error and returns when terminateDeployment throws', async () => {
+    api.terminateDeployment.mockRejectedValue(new Error('network error'));
+    const errLines = [];
+    console.error.mockImplementation(msg => errLines.push(msg));
+
+    await downCommand(config, ['dep-test-001'], chalk);
+
+    expect(errLines.join('\n')).toMatch(/network error|Could not stop/i);
+    expect(store.addReceipt).not.toHaveBeenCalled();
+  });
+});

package/tests/serve-lifecycle.test.js

@@ -498,3 +498,168 @@ describe('input validation for serve', () => {
     expect(process.exitCode).toBe(1);
   });
 });
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 11. llama.cpp runtime (--runtime llama.cpp --gguf)
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('--runtime llama.cpp', () => {
+  const HF_REPO = 'HauhauCS/Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive';
+  const HF_FILE = 'Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-Q4_K_M.gguf';
+
+  it('errors when --hf-repo or --hf-file are missing', async () => {
+    await serveCommand(config, ['--runtime', 'llama.cpp', '--max-cost', '10'], chalk);
+    expect(process.exitCode).toBe(1);
+    expect(api.callApi).not.toHaveBeenCalled();
+  });
+
+  it('errors when only --hf-repo is given (missing --hf-file)', async () => {
+    await serveCommand(config, ['--runtime', 'llama.cpp', '--hf-repo', HF_REPO, '--max-cost', '10'], chalk);
+    expect(process.exitCode).toBe(1);
+    expect(api.callApi).not.toHaveBeenCalled();
+  });
+
+  it('uses llama.cpp image with LLAMA_ARG_HF_REPO and LLAMA_ARG_HF_FILE env vars', async () => {
+    // --no-wait: only POST /serve called (1 mock needed)
+    api.callApi.mockResolvedValueOnce(makeServeDep());
+    global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200 });
+
+    const p = serveCommand(
+      config,
+      ['--runtime', 'llama.cpp', '--hf-repo', HF_REPO, '--hf-file', HF_FILE, '--max-cost', '10', '--no-wait'],
+      chalk,
+    );
+    await vi.advanceTimersByTimeAsync(100);
+    await p;
+
+    const body = api.callApi.mock.calls[0][1].body;
+    expect(body.image).toBe('michaelmanleyx/llama-cpp:server-cuda');
+    expect(body.env.LLAMA_ARG_HF_REPO).toBe(HF_REPO);
+    expect(body.env.LLAMA_ARG_HF_FILE).toBe(HF_FILE);
+    expect(body.model).toBeUndefined();
+    expect(process.exitCode).toBeFalsy();
+  });
+
+  it('health-checks /health (not /models)', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeServeDep())
+      .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,
+      ['--runtime', 'llama.cpp', '--hf-repo', HF_REPO, '--hf-file', HF_FILE, '--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('records deployment and receipt as ready on success', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeServeDep())
+      .mockResolvedValueOnce({ status: 'running' });
+
+    global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200 });
+
+    const p = serveCommand(
+      config,
+      ['--runtime', 'llama.cpp', '--hf-repo', HF_REPO, '--hf-file', HF_FILE, '--max-cost', '10'],
+      chalk,
+    );
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    expect(store.addDeployment).toHaveBeenCalledWith(expect.objectContaining({
+      id: 'dep-serve-001',
+    }));
+    expect(store.updateReceipt).toHaveBeenCalledWith('rcpt-serve-001', expect.objectContaining({
+      status: 'ready',
+    }));
+    expect(process.exitCode).toBeFalsy();
+  });
+
+  it('merges user --env with HF env vars', async () => {
+    // --no-wait: only POST /serve called (1 mock needed)
+    api.callApi.mockResolvedValueOnce(makeServeDep());
+    global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200 });
+
+    const p = serveCommand(
+      config,
+      ['--runtime', 'llama.cpp', '--hf-repo', HF_REPO, '--hf-file', HF_FILE,
+       '--env', 'CTX_SIZE=8192', '--max-cost', '10', '--no-wait'],
+      chalk,
+    );
+    await vi.advanceTimersByTimeAsync(100);
+    await p;
+
+    const body = api.callApi.mock.calls[0][1].body;
+    expect(body.env.LLAMA_ARG_HF_REPO).toBe(HF_REPO);
+    expect(body.env.LLAMA_ARG_HF_FILE).toBe(HF_FILE);
+    expect(body.env.CTX_SIZE).toBe('8192');
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 12. E2E smoke test — tiny HF GGUF (ggml-org/tiny-llamas / stories260K.gguf)
+//
+// Uses a real, publicly-available tiny GGUF (~1 MB) to verify the full
+// request lifecycle: arg parsing → correct serve body → /health polling →
+// receipt recorded as ready → OpenAI-compatible base URL returned.
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('llama.cpp E2E smoke — tiny GGUF (ggml-org/tiny-llamas)', () => {
+  const TINY_REPO = 'ggml-org/tiny-llamas';
+  const TINY_FILE = 'stories260K.gguf';
+
+  it('full lifecycle: arg parse → serve body → /health → ready receipt', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeServeDep({ model: undefined }))  // 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,
+      ['--runtime', 'llama.cpp',
+       '--hf-repo', TINY_REPO,
+       '--hf-file', TINY_FILE,
+       '--max-cost', '1'],
+      chalk,
+    );
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    // Correct image and env vars in the serve request
+    const body = api.callApi.mock.calls[0][1].body;
+    expect(body.image).toBe('michaelmanleyx/llama-cpp:server-cuda');
+    expect(body.env.LLAMA_ARG_HF_REPO).toBe(TINY_REPO);
+    expect(body.env.LLAMA_ARG_HF_FILE).toBe(TINY_FILE);
+    expect(body.model).toBeUndefined();
+
+    // Readiness check hits /health, not /models
+    expect(fetchedUrls.some(u => u.includes('/health'))).toBe(true);
+    expect(fetchedUrls.some(u => u.endsWith('/models'))).toBe(false);
+
+    // Receipt finalised as ready with endpoint URL
+    expect(store.updateReceipt).toHaveBeenCalledWith('rcpt-serve-001', expect.objectContaining({
+      status: 'ready',
+      endpointUrl: ENDPOINT_URL,
+    }));
+
+    expect(process.exitCode).toBeFalsy();
+  });
+});