badgr-cli 1.1.0 → 1.1.2

package/tests/connect.test.js

@@ -1,83 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-const store = {};
-vi.mock('../src/credentials.js', () => ({
-  KNOWN_PROVIDERS: ['anthropic', 'openai'],
-  getCredential: vi.fn(provider => store[provider] ?? null),
-  setCredential: vi.fn((provider, value) => { store[provider] = value; }),
-  removeCredential: vi.fn(provider => {
-    if (!(provider in store)) return false;
-    delete store[provider];
-    return true;
-  }),
-  listCredentials: vi.fn(() => Object.keys(store)),
-  CREDENTIALS_FILE: '/home/test/.badgr/credentials.json',
-}));
-
-const { connectCommand } = await import('../src/commands/connect.js');
-
-const chalk = { red: s => s, dim: s => s, green: s => s, bold: s => s, yellow: s => s, cyan: s => s };
-
-describe('connectCommand', () => {
-  beforeEach(() => {
-    process.exitCode = undefined;
-    vi.spyOn(console, 'log').mockImplementation(() => {});
-    vi.spyOn(console, 'error').mockImplementation(() => {});
-    for (const k of Object.keys(store)) delete store[k];
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    process.exitCode = undefined;
-  });
-
-  it('lists nothing connected when the store is empty', async () => {
-    await connectCommand([], chalk);
-    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(logged).toContain('No providers connected');
-  });
-
-  it('rejects an unknown provider', async () => {
-    await connectCommand(['aws'], chalk);
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('stores a credential with --key non-interactively', async () => {
-    await connectCommand(['anthropic', '--key', 'sk-ant-fake'], chalk);
-    expect(process.exitCode).toBeUndefined();
-    expect(store.anthropic).toBe('sk-ant-fake');
-    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(logged).toContain('Connected anthropic');
-  });
-
-  it('lists a connected provider', async () => {
-    await connectCommand(['anthropic', '--key', 'sk-ant-fake'], chalk);
-    await connectCommand([], chalk);
-    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(logged).toContain('anthropic');
-  });
-
-  it('removes a stored credential with --remove', async () => {
-    await connectCommand(['anthropic', '--key', 'sk-ant-fake'], chalk);
-    await connectCommand(['anthropic', '--remove'], chalk);
-    expect(store.anthropic).toBeUndefined();
-  });
-
-  it('`badgr connect list` lists connected providers instead of erroring as an unknown provider', async () => {
-    await connectCommand(['anthropic', '--key', 'sk-ant-fake'], chalk);
-    await connectCommand(['list'], chalk);
-    expect(process.exitCode).toBeUndefined();
-    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(logged).toContain('anthropic');
-  });
-
-  it('requires --key when not running in an interactive TTY', async () => {
-    await connectCommand(['anthropic'], chalk);
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('rejects an empty --key', async () => {
-    await connectCommand(['anthropic', '--key', '   '], chalk);
-    expect(process.exitCode).toBe(1);
-  });
-});

package/tests/detect.test.js

@@ -1,191 +0,0 @@
-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/down.test.js

@@ -1,150 +0,0 @@
-/**
- * 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, overrides = {}) {
-  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,
-    teardown_ok:   'ok',
-    ...overrides,
-  };
-}
-
-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('teardown not confirmed', () => {
-  it('reports unconfirmed status and never claims "Stopped" when the backend did not confirm teardown', async () => {
-    // A 200 response with teardown_ok: 'failed' — the DELETE was accepted
-    // but the backend could not confirm the provider resource is gone.
-    api.terminateDeployment.mockResolvedValue(makeStoppedDep(27 * 60, 0.34, { teardown_ok: 'failed' }));
-    const logLines = [];
-    vi.spyOn(console, 'log').mockImplementation(msg => logLines.push(msg ?? ''));
-
-    await downCommand(config, ['dep-test-001'], chalk);
-
-    const out = logLines.join('\n');
-    expect(out).not.toContain('✓ Stopped');
-    expect(out).toContain('not confirmed');
-    expect(store.addReceipt).toHaveBeenCalledWith(expect.objectContaining({
-      status: 'teardown_unconfirmed',
-    }));
-    console.log.mockRestore();
-  });
-});
-
-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/errors.test.js

@@ -1,130 +0,0 @@
-/**
- * Tests for the unified error catalog (errors.js).
- * Verifies that every catalog entry produces output matching the four CLI guarantees:
- *   1. What happened   (code + message in output)
- *   2. Retry status    (retried note when entry.retried === true)
- *   3. Billing status  (billing label in output)
- *   4. Next step       (at least one → hint in output)
- */
-import { describe, it, expect } from 'vitest';
-import { CATALOG, formatCliError } from '../src/errors.js';
-
-// Passthrough chalk mock — identical to what the lifecycle test suite uses.
-const chalk = new Proxy({}, {
-  get: () => (s) => s,
-});
-
-describe('CATALOG completeness', () => {
-  const REQUIRED_FIELDS = ['message', 'billing', 'retried', 'hint', 'severity'];
-  const VALID_BILLING   = ['never_started', 'stopped', 'check_receipt', 'charged'];
-  const VALID_SEVERITY  = ['P1', 'P2', 'P3', 'P4'];
-
-  for (const [code, entry] of Object.entries(CATALOG)) {
-    it(`${code} has all required fields`, () => {
-      for (const f of REQUIRED_FIELDS) {
-        expect(entry, `${code} missing field: ${f}`).toHaveProperty(f);
-      }
-      expect(VALID_BILLING, `${code}.billing invalid`).toContain(entry.billing);
-      expect(VALID_SEVERITY, `${code}.severity invalid`).toContain(entry.severity);
-    });
-  }
-});
-
-describe('formatCliError', () => {
-  it('includes the error code in the output', () => {
-    const out = formatCliError('NO_CAPACITY', {}, chalk);
-    expect(out).toContain('NO_CAPACITY');
-  });
-
-  it('includes billing label in output', () => {
-    const out = formatCliError('NO_CAPACITY', {}, chalk);
-    expect(out).toContain('Billing: never started');
-  });
-
-  it('includes a → hint line', () => {
-    const out = formatCliError('NO_CAPACITY', {}, chalk);
-    expect(out).toContain('→');
-  });
-
-  it('shows "Badgr retried automatically" only for retried=true entries', () => {
-    const retried = formatCliError('PROVISIONING_FAILED', {}, chalk);
-    expect(retried).toContain('Badgr retried automatically');
-
-    const notRetried = formatCliError('NO_CAPACITY', {}, chalk);
-    expect(notRetried).not.toContain('Badgr retried automatically');
-  });
-
-  it('does not expose internal fields by default', () => {
-    const out = formatCliError('PROVISIONING_FAILED', {}, chalk, { detail: 'SECRET_PROVIDER_URL' });
-    expect(out).not.toContain('SECRET_PROVIDER_URL');
-  });
-
-  it('exposes internal fields when BADGR_DEBUG=1', () => {
-    process.env.BADGR_DEBUG = '1';
-    try {
-      const out = formatCliError('PROVISIONING_FAILED', {}, chalk, { detail: 'SECRET_PROVIDER_URL' });
-      expect(out).toContain('SECRET_PROVIDER_URL');
-    } finally {
-      delete process.env.BADGR_DEBUG;
-    }
-  });
-
-  it('falls back gracefully for unknown codes', () => {
-    const out = formatCliError('TOTALLY_UNKNOWN_CODE', {}, chalk);
-    expect(out).toContain('TOTALLY_UNKNOWN_CODE');
-    expect(out).toContain('unexpected error');
-  });
-
-  // ── Specific catalog entries ──────────────────────────────────────────────
-
-  it('PROVISIONING_FAILED compat_failure contains incompatib and GPU type/image', () => {
-    const out = formatCliError('PROVISIONING_FAILED', { failure_category: 'compat_failure' }, chalk);
-    expect(out).toContain('incompatib');
-    expect(out).toMatch(/GPU type|image/i);
-  });
-
-  it('PROVISIONING_FAILED generic contains "failed to start" and "try again"', () => {
-    const out = formatCliError('PROVISIONING_FAILED', {}, chalk);
-    expect(out).toContain('failed to start');
-    expect(out).toMatch(/try again/i);
-    expect(out).not.toContain('incompatib');
-  });
-
-  it('NO_CAPACITY output contains "capacity" (satisfies /capacity/i test)', () => {
-    const out = formatCliError('NO_CAPACITY', {}, chalk);
-    expect(out).toMatch(/capacity/i);
-  });
-
-  it('TEARDOWN_FAILED is P1 severity', () => {
-    expect(CATALOG.TEARDOWN_FAILED.severity).toBe('P1');
-  });
-
-  it('TEARDOWN_FAILED billing is check_receipt', () => {
-    expect(CATALOG.TEARDOWN_FAILED.billing).toBe('check_receipt');
-  });
-
-  it('TEARDOWN_FAILED output contains billing warning', () => {
-    const out = formatCliError('TEARDOWN_FAILED', { deploymentId: 'dep-123', receiptId: 'rcpt-456' }, chalk);
-    expect(out).toContain('check your receipt');
-    expect(out).toContain('dep-123');
-  });
-
-  it('JOB_INFRASTRUCTURE_FAILURE billing is never_started', () => {
-    expect(CATALOG.JOB_INFRASTRUCTURE_FAILURE.billing).toBe('never_started');
-  });
-
-  it('HEALTH_CHECK_FAILED billing is stopped', () => {
-    expect(CATALOG.HEALTH_CHECK_FAILED.billing).toBe('stopped');
-  });
-
-  it('BILLING_INSUFFICIENT shows balance and required when provided', () => {
-    const out = formatCliError('BILLING_INSUFFICIENT', {
-      balance_usd: 1.23,
-      required_usd: 5.00,
-      topup_url: 'https://example.com/billing',
-    }, chalk);
-    expect(out).toContain('1.23');
-    expect(out).toContain('5.00');
-    expect(out).toContain('example.com/billing');
-  });
-});

package/tests/fallback-timeout.test.js

@@ -1,41 +0,0 @@
-/**
- * Regression test for a real production incident: the client-side /run
- * timeout (previously 130s) fired before the server's own routing/
- * provisioning deadline could, so the CLI reported "failed to submit" for
- * jobs that had actually been created and were already billing —
- * Future.result(timeout=...) on the backend never cancels the in-flight
- * work, so aborting client-side doesn't stop the server from finishing.
- *
- * The invariant that matters: this client timeout must stay comfortably
- * above backend/run_serve_routes.py's _PROVISION_TIMEOUT_SEC (200s default,
- * itself kept above deployment_service.py's 180s routing-search deadline —
- * see the comments at each of those three call sites, which all reference
- * this same chain). This test pins the client-side half of that chain so a
- * future edit can't silently drop it back below the server's deadline.
- */
-import { describe, it, expect, vi } from 'vitest';
-
-const mockCallApi = vi.fn().mockResolvedValue({ deployment_id: 'dep-1', cost_per_hour: 0.1 });
-vi.mock('../src/api.js', () => ({ callApi: (...args) => mockCallApi(...args) }));
-
-const { callWithFallback } = await import('../src/fallback.js');
-
-const chalk = { red: s => s, dim: s => s, yellow: s => s, bold: s => s, cyan: s => s };
-
-describe('callWithFallback /run timeout', () => {
-  it('uses a timeout comfortably above the backend\'s 200s provision deadline', async () => {
-    await callWithFallback(
-      '/run',
-      { apiKey: 'sk-test', baseUrl: 'https://api.test/v1' },
-      () => ({ image: 'busybox', command: ['echo', 'hi'] }),
-      '1',
-      chalk,
-      { thing: 'job', cmd: 'badgr run' },
-    );
-
-    expect(mockCallApi).toHaveBeenCalledTimes(1);
-    const [, opts] = mockCallApi.mock.calls[0];
-    const BACKEND_PROVISION_TIMEOUT_SEC = 200; // backend/run_serve_routes.py's _PROVISION_TIMEOUT_SEC default
-    expect(opts.timeoutMs).toBeGreaterThan(BACKEND_PROVISION_TIMEOUT_SEC * 1000);
-  });
-});