badgr-cli 1.0.31 → 1.0.34

package/tests/errors.test.js

@@ -0,0 +1,130 @@
+/**
+ * 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/launch-readiness.test.js

@@ -0,0 +1,326 @@
+/**
+ * Launch readiness — gap-filling tests for features on the outreach checklist
+ *
+ * Covers items missing from run-lifecycle and serve-lifecycle:
+ *   - badgr down  → terminates, writes receipt, prints cost summary
+ *   - badgr status → shows running deployments, rate, endpoint; empty state
+ *   - compat_failure error → correct user-facing message for CUDA mismatch
+ *   - failure_category surfaced → compat failure receipt shows failure reason
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// ── Module mocks ──────────────────────────────────────────────────────────────
+
+vi.mock('../src/api.js', () => ({
+  callApi:             vi.fn(),
+  terminateDeployment: vi.fn(),
+  listDeployments:     vi.fn(),
+}));
+
+vi.mock('../src/store.js', () => ({
+  addDeployment:        vi.fn(),
+  addReceipt:           vi.fn(),
+  updateReceipt:        vi.fn(),
+  generateReceiptId:    vi.fn(() => 'rcpt-down-001'),
+  generateDeploymentId: vi.fn(() => 'dep-down-001'),
+  listDeployments:      vi.fn(() => []),
+  listReceipts:         vi.fn(() => []),
+  findDeployment:       vi.fn(() => null),
+  updateDeployment:     vi.fn(),
+  removeDeployment:     vi.fn(),
+}));
+
+vi.mock('../src/config.js', () => ({
+  requireApiKey: vi.fn(),
+  loadConfig:    vi.fn(() => ({ apiKey: 'sk-test', baseUrl: 'https://api.test/v1' })),
+  saveConfig:    vi.fn(),
+}));
+
+import { downCommand }   from '../src/commands/down.js';
+import { statusCommand } from '../src/commands/status.js';
+import { callWithFallback, CapacityError } from '../src/fallback.js';
+import * as api   from '../src/api.js';
+import * as store from '../src/store.js';
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+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,
+};
+
+const NOW = 1_700_000_000;   // fixed unix timestamp
+const STARTED = NOW - 600;   // 10 minutes ago
+
+function makeTerminatedDep(overrides = {}) {
+  return {
+    deployment_id: 'dep-abc123',
+    gpu_type:      'RTX_4090',
+    cost_per_hour: 0.85,
+    started_at:    STARTED,
+    stopped_at:    NOW,
+    status:        'stopped',
+    ...overrides,
+  };
+}
+
+function makeRunningDep(overrides = {}) {
+  return {
+    deployment_id: 'dep-run-001',
+    workload_type: 'job',
+    gpu_type:      'A100',
+    gpu_count:     1,
+    cost_per_hour: 2.50,
+    status:        'running',
+    endpoint_url:  null,
+    model:         null,
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+  vi.spyOn(console, 'error').mockImplementation(() => {});
+  vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+  vi.clearAllMocks();
+  store.generateReceiptId.mockReturnValue('rcpt-down-001');
+  store.findDeployment.mockReturnValue(null);
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 1. badgr down
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('badgr down', () => {
+  it('calls terminateDeployment with the provided deployment ID', async () => {
+    api.terminateDeployment.mockResolvedValue(makeTerminatedDep());
+
+    await downCommand(config, ['dep-abc123'], chalk);
+
+    expect(api.terminateDeployment).toHaveBeenCalledWith(config, 'dep-abc123');
+  });
+
+  it('writes a receipt with runtime, finalCost, and action=badgr down', async () => {
+    api.terminateDeployment.mockResolvedValue(makeTerminatedDep());
+
+    await downCommand(config, ['dep-abc123'], chalk);
+
+    expect(store.addReceipt).toHaveBeenCalledWith(expect.objectContaining({
+      action:         'badgr down',
+      deploymentId:   'dep-abc123',
+      gpu:            'RTX_4090',
+      status:         'terminated',
+    }));
+    // Runtime should be ~600s (10 min window)
+    const call = store.addReceipt.mock.calls[0][0];
+    expect(call.runtimeSeconds).toBeGreaterThan(0);
+    expect(call.finalCost).toBeGreaterThan(0);
+  });
+
+  it('removes the local deployment record', async () => {
+    api.terminateDeployment.mockResolvedValue(makeTerminatedDep());
+
+    await downCommand(config, ['dep-abc123'], chalk);
+
+    expect(store.removeDeployment).toHaveBeenCalledWith('dep-abc123');
+  });
+
+  it('resolves local name to deployment ID via findDeployment', async () => {
+    store.findDeployment.mockReturnValue({ id: 'dep-abc123', name: 'my-job' });
+    api.terminateDeployment.mockResolvedValue(makeTerminatedDep());
+
+    await downCommand(config, ['my-job'], chalk);
+
+    expect(api.terminateDeployment).toHaveBeenCalledWith(config, 'dep-abc123');
+  });
+
+  it('prints error and returns without crashing on API failure', async () => {
+    api.terminateDeployment.mockRejectedValue(new Error('network error'));
+
+    await downCommand(config, ['dep-abc123'], chalk);
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining('Could not stop deployment'),
+    );
+    expect(store.addReceipt).not.toHaveBeenCalled();
+  });
+
+  it('prints usage hint when no deployment ID given', async () => {
+    await downCommand(config, [], chalk);
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining('Usage'),
+    );
+    expect(api.terminateDeployment).not.toHaveBeenCalled();
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 2. badgr status
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('badgr status', () => {
+  it('shows "Nothing running" when no active deployments', async () => {
+    api.listDeployments.mockResolvedValue({ deployments: [] });
+
+    await statusCommand(config, [], chalk);
+
+    const allOutput = console.log.mock.calls.flat().join(' ');
+    expect(allOutput).toContain('Nothing running');
+  });
+
+  it('displays running deployment with GPU type and billing rate', async () => {
+    api.listDeployments.mockResolvedValue({ deployments: [makeRunningDep()] });
+
+    await statusCommand(config, [], chalk);
+
+    const allOutput = console.log.mock.calls.flat().join(' ');
+    expect(allOutput).toContain('dep-run-001');
+    expect(allOutput).toContain('A100');
+    expect(allOutput).toContain('2.50');
+  });
+
+  it('shows endpoint URL for endpoint workloads', async () => {
+    api.listDeployments.mockResolvedValue({
+      deployments: [makeRunningDep({
+        workload_type: 'endpoint',
+        endpoint_url:  'https://dep-run-001.aibadgr.com/v1',
+      })],
+    });
+
+    await statusCommand(config, [], chalk);
+
+    const allOutput = console.log.mock.calls.flat().join(' ');
+    expect(allOutput).toContain('dep-run-001.aibadgr.com');
+  });
+
+  it('shows total billing rate when multiple deployments are running', async () => {
+    api.listDeployments.mockResolvedValue({
+      deployments: [
+        makeRunningDep({ deployment_id: 'dep-1', cost_per_hour: 1.20 }),
+        makeRunningDep({ deployment_id: 'dep-2', cost_per_hour: 2.50 }),
+      ],
+    });
+
+    await statusCommand(config, [], chalk);
+
+    const allOutput = console.log.mock.calls.flat().join(' ');
+    // Total: 1.20 + 2.50 = 3.70
+    expect(allOutput).toContain('3.70');
+  });
+
+  it('shows provisioning-state deployment as starting', async () => {
+    api.listDeployments.mockResolvedValue({
+      deployments: [makeRunningDep({ status: 'provisioning', cost_per_hour: 0 })],
+    });
+
+    await statusCommand(config, [], chalk);
+
+    const allOutput = console.log.mock.calls.flat().join(' ');
+    expect(allOutput).toContain('starting');
+  });
+
+  it('falls back to local store when API is unavailable', async () => {
+    api.listDeployments.mockRejectedValue(new Error('connection refused'));
+    store.listDeployments.mockReturnValue([
+      { id: 'dep-local-001', name: 'local-job', gpu: 'L40S', status: 'running', costPerHour: 1.10 },
+    ]);
+
+    await statusCommand(config, [], chalk);
+
+    const allOutput = console.log.mock.calls.flat().join(' ');
+    expect(allOutput).toContain('dep-local-001');
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 3. CUDA / compat failure error messages
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('compat_failure error message', () => {
+  function makeCompatError() {
+    const err = new Error('PROVISIONING_FAILED');
+    err.errorData = {
+      code:             'PROVISIONING_FAILED',
+      failure_category: 'compat_failure',
+    };
+    return err;
+  }
+
+  it('shows GPU/CUDA incompatibility message when failure_category is compat_failure', async () => {
+    api.callApi.mockRejectedValue(makeCompatError());
+
+    let thrown;
+    try {
+      await callWithFallback(
+        '/run',
+        { apiKey: 'sk-test', baseUrl: 'https://api.test/v1' },
+        () => ({ gpu: 'RTX_4090' }),
+        '1',
+        chalk,
+        { thing: 'job', cmd: 'badgr run' },
+      );
+    } catch (err) {
+      thrown = err;
+    }
+
+    expect(thrown).toBeInstanceOf(CapacityError);
+    expect(thrown.message).toContain('incompatib');
+  });
+
+  it('shows generic provisioning failure when failure_category is infrastructure', async () => {
+    const err = new Error('PROVISIONING_FAILED');
+    err.errorData = { code: 'PROVISIONING_FAILED', failure_category: 'infrastructure' };
+    api.callApi.mockRejectedValue(err);
+
+    let thrown;
+    try {
+      await callWithFallback(
+        '/run',
+        { apiKey: 'sk-test', baseUrl: 'https://api.test/v1' },
+        () => ({}),
+        '1',
+        chalk,
+        { thing: 'job', cmd: 'badgr run' },
+      );
+    } catch (err2) {
+      thrown = err2;
+    }
+
+    expect(thrown).toBeInstanceOf(CapacityError);
+    // Should NOT mention CUDA/compat
+    expect(thrown.message).not.toContain('incompatib');
+    expect(thrown.message).toContain('failed to start');
+  });
+
+  it('compat message mentions trying a different GPU type or image', async () => {
+    api.callApi.mockRejectedValue(makeCompatError());
+
+    let thrown;
+    try {
+      await callWithFallback(
+        '/run',
+        { apiKey: 'sk-test', baseUrl: 'https://api.test/v1' },
+        () => ({}),
+        '2',
+        chalk,
+        { thing: 'job', cmd: 'badgr run' },
+      );
+    } catch (err) {
+      thrown = err;
+    }
+
+    expect(thrown.message).toMatch(/GPU type|image/i);
+  });
+});

package/tests/router.test.js

@@ -1,10 +1,14 @@
 import { describe, it, expect } from 'vitest';
 import {
   findById, findByCanonical, findCheapest, listAll,
-  getRoutePlan, estimateCost,
-  GPU_CATALOG, PROVIDER_CATALOG,
+  estimateCost,
+  GPU_CATALOG,
 } from '../src/router.js';
 
+// getRoutePlan and PROVIDER_CATALOG have been removed from the CLI.
+// Provider routing is now server-side only. Tests below cover the
+// remaining local GPU catalog helpers.
+
 describe('findById', () => {
   it('finds GPU by id', () => {
     expect(findById('rtx-4090').name).toContain('4090');
@@ -67,43 +71,6 @@ describe('listAll', () => {
   });
 });
 
-describe('getRoutePlan', () => {
-  it('returns lane1 and lane2 for RTX_4090', () => {
-    const plan = getRoutePlan('RTX_4090');
-    expect(plan.lane1).toBeTruthy();
-    expect(plan.lane2.length).toBeGreaterThan(0);
-  });
-
-  it('lane2 is sorted cheapest-first', () => {
-    const plan = getRoutePlan('RTX_4090');
-    for (let i = 1; i < plan.lane2.length; i++) {
-      expect(plan.lane2[i].ratePerHour).toBeGreaterThanOrEqual(plan.lane2[i - 1].ratePerHour);
-    }
-  });
-
-  it('scales ratePerHour by count', () => {
-    const plan1 = getRoutePlan('RTX_4090', 1);
-    const plan2 = getRoutePlan('RTX_4090', 2);
-    expect(plan2.lane2[0].ratePerHour).toBeCloseTo(plan1.lane2[0].ratePerHour * 2, 5);
-  });
-
-  it('cheapestRate matches first provider rate', () => {
-    const plan = getRoutePlan('H100');
-    expect(plan.cheapestRate).toBe(plan.lane2[0].ratePerHour);
-  });
-
-  it('costWithOverhead > cheapestRate', () => {
-    const plan = getRoutePlan('RTX_4090');
-    expect(plan.costWithOverhead).toBeGreaterThan(plan.cheapestRate);
-  });
-
-  it('includes gpu info for known canonical', () => {
-    const plan = getRoutePlan('H100');
-    expect(plan.gpu).not.toBeNull();
-    expect(plan.gpu.id).toBe('h100');
-  });
-});
-
 describe('estimateCost', () => {
   it('calculates cost for 60 minutes = 1 hour', () => {
     expect(estimateCost(1.10, 60)).toBeCloseTo(1.10, 5);
@@ -124,34 +91,8 @@ describe('L40S', () => {
     expect(findByCanonical('L40S').vramGb).toBe(48);
   });
 
-  it('has provider pricing in PROVIDER_CATALOG', () => {
-    expect(Array.isArray(PROVIDER_CATALOG['L40S'])).toBe(true);
-    expect(PROVIDER_CATALOG['L40S'].length).toBeGreaterThan(0);
-  });
-
-  it('route plan is cheapest-first for L40S', () => {
-    const plan = getRoutePlan('L40S');
-    expect(plan.lane2.length).toBeGreaterThan(0);
-    for (let i = 1; i < plan.lane2.length; i++) {
-      expect(plan.lane2[i].ratePerHour).toBeGreaterThanOrEqual(plan.lane2[i - 1].ratePerHour);
-    }
-  });
-});
-
-describe('PROVIDER_CATALOG', () => {
-  it('exists for all GPU_CATALOG canonical types', () => {
-    const catalogCanonicals = [...new Set(GPU_CATALOG.map(g => g.canonical))];
-    catalogCanonicals.forEach(c => {
-      // Some may not have provider pricing — just check the ones that do are valid arrays
-      if (PROVIDER_CATALOG[c]) {
-        expect(Array.isArray(PROVIDER_CATALOG[c])).toBe(true);
-        PROVIDER_CATALOG[c].forEach(p => {
-          expect(p.provider).toBeTruthy();
-          expect(p.ratePerHour).toBeGreaterThan(0);
-          expect(p.reliability).toBeGreaterThan(0);
-          expect(p.reliability).toBeLessThanOrEqual(1);
-        });
-      }
-    });
+  it('has no PROVIDER_CATALOG (provider routing is server-side)', async () => {
+    const mod = await import('../src/router.js');
+    expect(mod.PROVIDER_CATALOG).toBeUndefined();
   });
 });