badgr-cli 1.0.47 → 1.1.0

package/tests/secrets.test.js

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

@@ -0,0 +1,77 @@
+import { describe, it, expect } from 'vitest';
+import { parseSlurmScript, envForArrayTask, SlurmParseError } from '../src/slurm.js';
+
+const BASIC = `#!/bin/bash
+#SBATCH --job-name=train
+#SBATCH --cpus-per-task=32
+#SBATCH --mem=128G
+#SBATCH --gres=gpu:a100:2
+#SBATCH --time=02:30:00
+#SBATCH --export=FOO=bar,BAZ=qux
+
+python train.py --epochs 10
+`;
+
+const ARRAY = `#!/bin/bash
+#SBATCH --job-name=screen
+#SBATCH --array=1-100:5
+#SBATCH --gpus=1
+#SBATCH --partition=gpu-fast
+#SBATCH --mail-user=someone@example.com
+
+python screen.py --scenario $SLURM_ARRAY_TASK_ID
+`;
+
+describe('parseSlurmScript', () => {
+  it('parses cpus, mem, gres, time, export', () => {
+    const job = parseSlurmScript(BASIC, { filename: 'train.slurm' });
+    expect(job.name).toBe('train');
+    expect(job.cpus).toBe(32);
+    expect(job.memGb).toBeCloseTo(128);
+    expect(job.gpuCount).toBe(2);
+    expect(job.gpuType).toBe('a100');
+    expect(job.timeMinutes).toBe(150);
+    expect(job.env).toEqual({ FOO: 'bar', BAZ: 'qux' });
+    expect(job.command).toContain('python train.py --epochs 10');
+    expect(job.arrayIndices).toEqual([]);
+  });
+
+  it('parses --array ranges with a step and ignores unknown directives', () => {
+    const job = parseSlurmScript(ARRAY, { filename: 'screen.slurm' });
+    expect(job.arrayIndices).toEqual([1, 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56, 61, 66, 71, 76, 81, 86, 91, 96]);
+    expect(job.gpuCount).toBe(1);
+    expect(job.ignoredDirectives).toContain('--partition=gpu-fast');
+    expect(job.ignoredDirectives).toContain('--mail-user=someone@example.com');
+  });
+
+  it('parses mem-per-cpu combined with cpus-per-task', () => {
+    const job = parseSlurmScript(`#SBATCH --cpus-per-task=4\n#SBATCH --mem-per-cpu=2G\necho hi\n`);
+    expect(job.memGb).toBeCloseTo(8);
+  });
+
+  it('parses simple comma/range --array lists', () => {
+    const job = parseSlurmScript(`#SBATCH --array=1,3,5-7\necho hi\n`);
+    expect(job.arrayIndices).toEqual([1, 3, 5, 6, 7]);
+  });
+
+  it('throws when there is no runnable command', () => {
+    expect(() => parseSlurmScript(`#!/bin/bash\n#SBATCH --job-name=empty\n`)).toThrow(SlurmParseError);
+  });
+
+  it('supports export lines in the script body in addition to --export', () => {
+    const job = parseSlurmScript(`#SBATCH --job-name=x\nexport MODE="fast"\npython run.py\n`);
+    expect(job.env.MODE).toBe('fast');
+  });
+});
+
+describe('envForArrayTask', () => {
+  it('injects SLURM_ARRAY_TASK_ID/JOB_ID on top of the base env', () => {
+    const env = envForArrayTask({ FOO: 'bar' }, 7, 'rcpt-123');
+    expect(env).toEqual({ FOO: 'bar', SLURM_ARRAY_TASK_ID: '7', SLURM_ARRAY_JOB_ID: 'rcpt-123' });
+  });
+
+  it('leaves env untouched for non-array jobs', () => {
+    const env = envForArrayTask({ FOO: 'bar' }, null, null);
+    expect(env).toEqual({ FOO: 'bar' });
+  });
+});

package/tests/spec.test.js

@@ -1,5 +1,20 @@
 import { describe, it, expect } from 'vitest';
-import { parseSpec, validateSpec, specLines, parseFlags, normalizeGpuType } from '../src/spec.js';
+import { parseSpec, validateSpec, specLines, parseFlags, normalizeGpuType, VM_CLASSES, LAUNCH_VM_SIZES, vmClassForWorkload, parseGbSize } from '../src/spec.js';
+
+describe('vmClassForWorkload — deterministic workload → VM class table', () => {
+  it('maps playwright to browser', () => expect(vmClassForWorkload('playwright')).toBe('browser'));
+  it('maps cline/claude/codex to small', () => {
+    expect(vmClassForWorkload('cline')).toBe('small');
+    expect(vmClassForWorkload('claude')).toBe('small');
+    expect(vmClassForWorkload('codex')).toBe('small');
+  });
+  it('defaults an unknown/explicit-form workload (null) to small', () => {
+    expect(vmClassForWorkload(null)).toBe('small');
+  });
+  it('every LAUNCH_VM_SIZES entry has a VM_CLASSES definition', () => {
+    for (const size of LAUNCH_VM_SIZES) expect(VM_CLASSES[size]).toBeTruthy();
+  });
+});
 
 describe('normalizeGpuType', () => {
   it('maps RTX-4090 to RTX_4090', () => expect(normalizeGpuType('RTX-4090')).toBe('RTX_4090'));
@@ -141,3 +156,46 @@ describe('specLines', () => {
     expect(lines.every(l => l !== null)).toBe(true);
   });
 });
+
+
+describe('CPU compute sizing', () => {
+  it('selects CPU compute and heuristic size for agent tasks', async () => {
+    const { parseSpec } = await import('../src/spec.js');
+    const spec = parseSpec(['--type', 'job', '--compute', 'cpu', '--agent', 'claude', '--task', 'run e2e tests']);
+    expect(spec.compute).toBe('cpu');
+    expect(spec.gpu).toBe('CPU');
+    expect(spec.cpuSize).toBe('large');
+  });
+});
+
+describe('parseGbSize', () => {
+  it('parses a plain GB suffix', () => {
+    expect(parseGbSize('64GB')).toBe(64);
+    expect(parseGbSize('64G')).toBe(64);
+  });
+
+  it('parses MB/TB/KB and converts to GB', () => {
+    expect(parseGbSize('65536MB')).toBeCloseTo(64);
+    expect(parseGbSize('1TB')).toBe(1024);
+    expect(parseGbSize('1048576KB')).toBeCloseTo(1);
+  });
+
+  it('is case-insensitive', () => {
+    expect(parseGbSize('24gb')).toBe(24);
+  });
+
+  it('defaults a bare number to GB unless bareUnit overrides it', () => {
+    expect(parseGbSize('24')).toBe(24);
+    expect(parseGbSize('2048', { bareUnit: 'M' })).toBe(2);
+  });
+
+  it('accepts a number input directly', () => {
+    expect(parseGbSize(32)).toBe(32);
+  });
+
+  it('returns null for unparseable input', () => {
+    expect(parseGbSize('not-a-size')).toBeNull();
+    expect(parseGbSize(null)).toBeNull();
+    expect(parseGbSize(undefined)).toBeNull();
+  });
+});

package/tests/status.test.js

@@ -0,0 +1,73 @@
+/**
+ * badgr status — must show every non-terminal deployment, not just
+ * "running"/"provisioning". A live run found deployments stuck in
+ * "starting" that used to be silently dropped, reporting "Nothing
+ * running" while real billable resources kept running.
+ */
+import { describe, it, expect, vi } from 'vitest';
+
+vi.mock('../src/api.js', () => ({
+  listDeployments: vi.fn(),
+}));
+
+vi.mock('../src/store.js', () => ({
+  listDeployments: vi.fn(() => []),
+}));
+
+import { statusCommand } from '../src/commands/status.js';
+import { listDeployments as apiDeployments } from '../src/api.js';
+
+const chalk = new Proxy({}, { get: () => (s) => s });
+
+function makeDep(overrides) {
+  return {
+    deployment_id: 'dep-001',
+    name: 'dep-001',
+    workload_type: 'job',
+    gpu_type: 'A100',
+    gpu_count: 1,
+    cost_per_hour: 0.5,
+    ...overrides,
+  };
+}
+
+async function runStatus(deployments) {
+  apiDeployments.mockResolvedValueOnce({ deployments });
+  const logs = [];
+  const spy = vi.spyOn(console, 'log').mockImplementation((...args) => logs.push(args.join(' ')));
+  await statusCommand({ apiKey: 'test-key' }, [], chalk);
+  spy.mockRestore();
+  return logs.join('\n');
+}
+
+describe('statusCommand', () => {
+  for (const status of ['running', 'provisioning', 'starting', 'queued']) {
+    it(`shows a deployment in "${status}" status as active, not hidden`, async () => {
+      const out = await runStatus([makeDep({ status })]);
+      expect(out).not.toContain('Nothing running');
+      expect(out).toContain('dep-001');
+    });
+  }
+
+  for (const status of ['completed', 'succeeded', 'success', 'failed', 'stopped']) {
+    it(`excludes a deployment in terminal status "${status}"`, async () => {
+      const out = await runStatus([makeDep({ status })]);
+      expect(out).toContain('Nothing running');
+      expect(out).not.toContain('dep-001');
+    });
+  }
+
+  it('reports "Nothing running" when there are no deployments at all', async () => {
+    const out = await runStatus([]);
+    expect(out).toContain('Nothing running');
+  });
+
+  it('shows the running badge for status "running" and a starting-style badge otherwise', async () => {
+    const out = await runStatus([
+      makeDep({ deployment_id: 'dep-run', status: 'running' }),
+      makeDep({ deployment_id: 'dep-start', status: 'starting' }),
+    ]);
+    expect(out).toContain('running');
+    expect(out).toContain('starting');
+  });
+});

package/tests/task.test.js

@@ -0,0 +1,109 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { taskCommand } from '../src/commands/task.js';
+
+const chalk = { red: s => s, dim: s => s, green: s => s, bold: s => s, yellow: s => s, cyan: s => s };
+const config = { apiKey: 'test-key', baseUrl: 'https://example.test/v1' };
+
+describe('taskCommand', () => {
+  beforeEach(() => {
+    process.exitCode = undefined;
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    process.exitCode = undefined;
+  });
+
+  it('requires a description', async () => {
+    await taskCommand(config, [], chalk);
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('is a thin wrapper: prints the description, then delegates to `badgr launch . -- <command>`', async () => {
+    await taskCommand(config, [
+      'Run the Chromium tests and tell me what failed',
+      '--dry-run', '--max-cost', '1', '--', 'npm', 'run', 'test:chromium',
+    ], chalk);
+
+    expect(process.exitCode).toBeUndefined();
+    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).toContain('Task: Run the Chromium tests and tell me what failed');
+    expect(logged).toContain('Compute:');
+    expect(logged).toContain('CPU VM');
+    expect(logged).toContain('npm run test:chromium');
+  });
+
+  it('supports an agent prompt as the command', async () => {
+    await taskCommand(config, [
+      'Fix the failing checkout test',
+      '--dry-run', '--max-cost', '1',
+      '--', 'claude', '-p', 'Fix the failing checkout test',
+    ], chalk);
+
+    expect(process.exitCode).toBeUndefined();
+    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).toContain('claude -p Fix the failing checkout test');
+  });
+
+  it('bubbles up errors from the underlying launch (e.g. --gpu rejection)', async () => {
+    await taskCommand(config, [
+      'Fix the checkout bug',
+      '--gpu', 'A100', '--dry-run', '--', 'claude', '-p', 'fix',
+    ], chalk);
+    expect(process.exitCode).toBe(1);
+    const logged = console.error.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).toContain('CPU VM');
+  });
+
+  it('bubbles up a missing-command error the same way badgr launch would', async () => {
+    await taskCommand(config, ['Fix the checkout bug'], chalk);
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('accepts the quoted --cmd form as the command', async () => {
+    await taskCommand(config, [
+      'Run tests',
+      '--dry-run', '--max-cost', '1', '--cmd', 'npm run test:chromium',
+    ], chalk);
+    expect(process.exitCode).toBeUndefined();
+    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).toContain('npm run test:chromium');
+  });
+
+  it('always launches against the current directory, never the description text', async () => {
+    await taskCommand(config, [
+      'Run the Chromium tests',
+      '--dry-run', '--max-cost', '1', '--', 'npm', 'test',
+    ], chalk);
+    expect(process.exitCode).toBeUndefined();
+    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).not.toContain('Source:       Run the Chromium tests');
+  });
+
+  it('forwards --artifacts through to the underlying launch', async () => {
+    await taskCommand(config, [
+      'Run the Chromium tests and tell me what failed',
+      '--dry-run', '--max-cost', '1',
+      '--artifacts', 'playwright-report',
+      '--', 'npx', 'playwright', 'test',
+    ], chalk);
+    expect(process.exitCode).toBeUndefined();
+    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).toContain('Artifacts:');
+    expect(logged).toContain('playwright-report');
+  });
+
+  it('rejects a flag placed before the description instead of silently treating it as the task text', async () => {
+    // Regression: `badgr task --max-cost 1 "fix" -- npm test` used to treat
+    // "--max-cost" itself as the description ("Task: --max-cost"), then fail
+    // downstream with a confusing "Unexpected extra arguments" error that
+    // never explained the real cause.
+    await taskCommand(config, ['--max-cost', '1', 'Fix login bug', '--', 'npm', 'test'], chalk);
+    expect(process.exitCode).toBe(1);
+    const logged = console.error.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).toContain('description must come first');
+    expect(console.log).not.toHaveBeenCalledWith(expect.stringContaining('Task: --max-cost'));
+  });
+});

package/tests/template.test.js

@@ -29,6 +29,13 @@ vi.mock('../src/api.js', () => ({
 }));
 
 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,
+  }),
   addDeployment:        vi.fn(),
   addReceipt:           vi.fn(),
   updateReceipt:        vi.fn(),