badgr-cli 1.1.1 → 1.1.3

package/tests/sbatch.test.js

@@ -1,190 +0,0 @@
-/**
- * badgr sbatch — /run body translation from #SBATCH directives, dry-run
- * behavior, and job-array fan-out (one deployment per task index).
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, writeFileSync, rmSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-
-vi.mock('../src/store.js', () => ({
-  selectedComputeFromDeployment: (dep) => ({
-    gpu: dep.gpu_type ?? null,
-    gpuCount: dep.gpu_count ?? null,
-    vcpus: dep.selected_vcpus ?? null,
-    ramGb: dep.selected_ram_gb ?? null,
-    vramGb: dep.selected_vram_gb ?? null,
-  }),
-  addReceipt: vi.fn(),
-  updateReceipt: vi.fn(),
-  generateReceiptId: vi.fn(() => 'rcpt-sbatch-001'),
-  loadStore: vi.fn(() => ({ receipts: [], deployments: [] })),
-}));
-
-vi.mock('../src/api.js', () => ({
-  callApi: vi.fn(),
-}));
-
-vi.mock('../src/fallback.js', async (importOriginal) => {
-  const actual = await importOriginal();
-  return { ...actual, callWithFallback: vi.fn() };
-});
-
-vi.mock('../src/batch.js', () => ({
-  monitorBatchJob: vi.fn(() => Promise.resolve({ status: 'succeeded', exitCode: 0, runtimeMs: 5000, reason: 'complete' })),
-  fmtRuntime: (ms) => `${Math.round(ms / 1000)}s`,
-}));
-
-import { sbatchCommand, buildRunBody } from '../src/commands/sbatch.js';
-import * as store from '../src/store.js';
-import * as api from '../src/api.js';
-import * as fallback from '../src/fallback.js';
-
-const chalk = {
-  bold: s => s, dim: s => s, red: s => s, yellow: s => s, green: s => s, cyan: s => s,
-};
-
-const config = { apiKey: 'sk-test', baseUrl: 'https://api.test/v1' };
-
-let dir;
-beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), 'badgr-sbatch-cmd-test-'));
-  process.exitCode = undefined;
-  vi.spyOn(console, 'log').mockImplementation(() => {});
-  vi.spyOn(console, 'error').mockImplementation(() => {});
-  vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-  vi.clearAllMocks();
-});
-
-afterEach(() => {
-  rmSync(dir, { recursive: true, force: true });
-  vi.restoreAllMocks();
-});
-
-describe('buildRunBody', () => {
-  it('translates a GPU job into the /run body shape', () => {
-    const job = {
-      name: 'train', command: 'python train.py', cpus: 32, memGb: 128,
-      gpuCount: 2, gpuType: 'a100', env: { FOO: 'bar' },
-    };
-    const body = buildRunBody(job, {
-      image: 'python:3.11-slim', tier: '1', region: null,
-      maxCostUsd: 5, maxRuntimeMinutes: 60,
-    });
-    expect(body.command).toEqual(['bash', '-lc', 'python train.py']);
-    expect(body.gpu).toBe('A100');
-    expect(body.gpu_count).toBe(2);
-    expect(body.cpu).toBe(32);
-    expect(body.memory_gb).toBe(128);
-    expect(body.env).toEqual({ FOO: 'bar' });
-    expect(body.max_cost_usd).toBe(5);
-    expect(body.max_runtime_seconds).toBe(3600);
-    expect(body.name).toBe('train');
-  });
-
-  it('requests no GPU when the script has no gres/gpus directive', () => {
-    const job = { name: 'cpu-job', command: 'echo hi', cpus: null, memGb: null, gpuCount: 0, gpuType: null, env: {} };
-    const body = buildRunBody(job, { image: 'python:3.11-slim', tier: '1', region: null, maxCostUsd: 1, maxRuntimeMinutes: 10 });
-    expect(body.gpu).toBe('NONE');
-    // Backend's RunBody requires gpu_count >= 1; CPU-only routing goes through
-    // the separate no_gpu flag instead of gpu_count: 0 (which the real
-    // Pydantic-validated backend rejects with a 422 before provisioning).
-    expect(body.gpu_count).toBe(1);
-    expect(body.no_gpu).toBe(true);
-  });
-
-  it('suffixes the name and injects SLURM_ARRAY_TASK_ID for array tasks', () => {
-    const job = { name: 'screen', command: 'python screen.py', cpus: null, memGb: null, gpuCount: 1, gpuType: null, env: {} };
-    const body = buildRunBody(job, { image: 'python:3.11-slim', tier: '1', region: null, maxCostUsd: 1, maxRuntimeMinutes: 10, taskId: 7, arrayJobId: 'rcpt-x' });
-    expect(body.name).toBe('screen-7');
-    expect(body.env.SLURM_ARRAY_TASK_ID).toBe('7');
-    expect(body.env.SLURM_ARRAY_JOB_ID).toBe('rcpt-x');
-  });
-});
-
-describe('sbatchCommand', () => {
-  function writeScript(name, contents) {
-    const p = join(dir, name);
-    writeFileSync(p, contents);
-    return p;
-  }
-
-  it('dry-run parses and prints the plan without calling the network', async () => {
-    const scriptPath = writeScript('job.slurm', `#!/bin/bash\n#SBATCH --job-name=t\n#SBATCH --gres=gpu:1\npython run.py\n`);
-    await sbatchCommand(config, [scriptPath, '--dry-run'], chalk);
-    expect(fallback.callWithFallback).not.toHaveBeenCalled();
-    expect(process.exitCode).toBeUndefined();
-  });
-
-  it('submits a single job and reports success', async () => {
-    const scriptPath = writeScript('job.slurm', `#!/bin/bash\n#SBATCH --job-name=t\n#SBATCH --gres=gpu:1\npython run.py\n`);
-
-    fallback.callWithFallback.mockResolvedValue({
-      deployment_id: 'dep-1', receipt_id: 'rcpt-1', gpu_type: 'RTX_4090',
-      gpu_count: 1, cost_per_hour: 0.5, provider: 'runpod', tier: '1', status: 'running',
-    });
-    api.callApi.mockResolvedValue({
-      status: 'succeeded', failure_reason: null, teardown_ok: 'ok',
-      runtime_seconds: 5, accrued_cost_usd: 0.01, provider: 'runpod',
-    });
-
-    await sbatchCommand(config, [scriptPath], chalk);
-
-    expect(fallback.callWithFallback).toHaveBeenCalledTimes(1);
-    expect(store.addReceipt).toHaveBeenCalledTimes(1);
-    expect(store.addReceipt).toHaveBeenCalledWith(expect.objectContaining({
-      workloadShape: 'slurm',
-      computeSelected: expect.objectContaining({ gpu: 'RTX_4090', gpuCount: 1 }),
-    }));
-    expect(process.exitCode).toBeUndefined();
-  });
-
-  it('fans out array jobs into one deployment per task', async () => {
-    const scriptPath = writeScript('array.slurm', `#!/bin/bash\n#SBATCH --job-name=screen\n#SBATCH --array=1-3\n#SBATCH --gpus=1\npython screen.py\n`);
-
-    let callCount = 0;
-    fallback.callWithFallback.mockImplementation(() => {
-      callCount += 1;
-      return Promise.resolve({
-        deployment_id: `dep-${callCount}`, receipt_id: `rcpt-${callCount}`, gpu_type: 'RTX_4090',
-        gpu_count: 1, cost_per_hour: 0.5, provider: 'runpod', tier: '1', status: 'running',
-      });
-    });
-    api.callApi.mockResolvedValue({
-      status: 'succeeded', failure_reason: null, teardown_ok: 'ok',
-      runtime_seconds: 5, accrued_cost_usd: 0.01, provider: 'runpod',
-    });
-
-    await sbatchCommand(config, [scriptPath], chalk);
-
-    expect(fallback.callWithFallback).toHaveBeenCalledTimes(3);
-    expect(store.addReceipt).toHaveBeenCalledTimes(3);
-    expect(store.addReceipt).toHaveBeenCalledWith(expect.objectContaining({ workloadShape: 'slurm-array' }));
-    expect(process.exitCode).toBeUndefined();
-  });
-
-  it('reports failure exit code when a task does not succeed', async () => {
-    const scriptPath = writeScript('job.slurm', `#!/bin/bash\n#SBATCH --gres=gpu:1\npython run.py\n`);
-    const { monitorBatchJob } = await import('../src/batch.js');
-    monitorBatchJob.mockResolvedValueOnce({ status: 'failed', exitCode: 1, runtimeMs: 1000, reason: 'infrastructure' });
-
-    fallback.callWithFallback.mockResolvedValue({
-      deployment_id: 'dep-1', receipt_id: 'rcpt-1', gpu_type: 'RTX_4090',
-      gpu_count: 1, cost_per_hour: 0.5, provider: 'runpod', tier: '1', status: 'running',
-    });
-    api.callApi.mockResolvedValue({
-      status: 'failed', failure_reason: 'infrastructure', teardown_ok: 'ok',
-      runtime_seconds: 1, accrued_cost_usd: 0.01, provider: 'runpod',
-    });
-
-    await sbatchCommand(config, [scriptPath], chalk);
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('errors before touching the network when the script has no command', async () => {
-    const scriptPath = writeScript('empty.slurm', `#!/bin/bash\n#SBATCH --job-name=empty\n`);
-    await sbatchCommand(config, [scriptPath], chalk);
-    expect(process.exitCode).toBe(1);
-    expect(fallback.callWithFallback).not.toHaveBeenCalled();
-  });
-});

package/tests/secrets.test.js

@@ -1,16 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import fs from 'fs';
-import path from 'path';
-
-describe('badgr secrets (removed)', () => {
-  it('no longer ships commands/secrets.js', () => {
-    const file = path.join(__dirname, '../src/commands/secrets.js');
-    expect(fs.existsSync(file)).toBe(false);
-  });
-
-  it('badgr.js has no case for the secrets command', async () => {
-    const badgrSrc = fs.readFileSync(path.join(__dirname, '../src/badgr.js'), 'utf8');
-    expect(badgrSrc).not.toMatch(/case 'secrets'/);
-    expect(badgrSrc).not.toContain('commands/secrets.js');
-  });
-});

package/tests/serve-apps.test.js

@@ -1,189 +0,0 @@
-/**
- * `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');
-  });
-});