badgr-cli 1.0.48 → 1.1.0

package/tests/batch.test.js

@@ -9,6 +9,13 @@ 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-batch-001'),
@@ -48,6 +55,7 @@ import {
   displayFailureReason,
   missingOutputPaths,
   readMetricFile,
+  nextArchiveTmpFile,
 } from '../src/commands/batch.js';
 import * as store from '../src/store.js';
 import * as api from '../src/api.js';
@@ -99,6 +107,26 @@ describe('displayFailureReason', () => {
 // missingOutputPaths / readMetricFile
 // ---------------------------------------------------------------------------
 
+describe('nextArchiveTmpFile', () => {
+  it('never returns the same path twice, even called back-to-back in the same millisecond', () => {
+    // Regression test: the original implementation used only Date.now() for
+    // the temp filename, which collides when --fan-out builds multiple
+    // archives in the same millisecond (routine once concurrency > 1),
+    // corrupting one task's archive out from under another and silently
+    // dropping tasks. A monotonic counter fixes it — assert directly rather
+    // than through the full CLI/filesystem, since the guarantee is about the
+    // string, not the I/O around it.
+    const paths = new Set();
+    for (let i = 0; i < 500; i++) paths.add(nextArchiveTmpFile());
+    expect(paths.size).toBe(500);
+  });
+
+  it('always includes the badgr-batch-inputs prefix and .tar.gz suffix', () => {
+    const p = nextArchiveTmpFile();
+    expect(p).toMatch(/badgr-batch-inputs-\d+-\d+\.tar\.gz$/);
+  });
+});
+
 describe('missingOutputPaths', () => {
   it('reports declared paths that do not exist under the extraction dir', () => {
     mkdirSync(join(dir, 'outputs'), { recursive: true });
@@ -195,6 +223,7 @@ success_metric:
     expect(JSON.parse(capturedBody.env.BADGR_OUTPUT_PATHS_JSON)).toEqual([
       '/outputs/metrics.json', '/outputs/videos', '/outputs/logs',
     ]);
+    expect(store.addReceipt).toHaveBeenCalledWith(expect.objectContaining({ workloadShape: 'container-batch' }));
   });
 
   it('rejects a workload.yml missing required fields before touching the network', async () => {
@@ -205,6 +234,23 @@ success_metric:
     expect(fallback.callWithFallback).not.toHaveBeenCalled();
   });
 
+  it('--dry-run never submits — regression: this flag was previously silently ignored, submitting real GPU jobs anyway', async () => {
+    // Found live: `badgr batch run workload.yml --dry-run` (and the
+    // --fan-out form below) provisioned real GPU deployments despite
+    // --dry-run, because the flag was never parsed or checked anywhere in
+    // this file — every real submission this test guards against actually
+    // happened once, on real infrastructure, before this fix.
+    const yamlPath = join(dir, 'workload.yml');
+    writeFileSync(yamlPath, 'name: t\nimage: busybox\ncommand: [echo, hi]\nmax_cost: 1\nmax_runtime_minutes: 5\n');
+
+    await batchCommand(config, ['run', yamlPath, '--dry-run'], chalk);
+
+    expect(process.exitCode).toBeUndefined();
+    expect(fallback.callWithFallback).not.toHaveBeenCalled();
+    expect(api.uploadBlob).not.toHaveBeenCalled();
+    expect(store.addReceipt).not.toHaveBeenCalled();
+  });
+
   it('builds a body with no BADGR_* env vars when inputs/outputs are omitted', async () => {
     const yamlPath = join(dir, 'workload.yml');
     writeFileSync(yamlPath, `
@@ -237,6 +283,272 @@ max_runtime_minutes: 5
   });
 });
 
+// ---------------------------------------------------------------------------
+// badgr batch run --fan-out <dir> — "run one program across many inputs"
+// ---------------------------------------------------------------------------
+
+describe('badgr batch run --fan-out', () => {
+  function writeFanOutYaml(dirPath, extra = '') {
+    const yamlPath = join(dirPath, 'workload.yml');
+    writeFileSync(yamlPath, `
+name: screen
+image: badgr/screen:latest
+command: [python, screen.py, --input, /inputs/scenario.json]
+inputs:
+  - ./scenarios/PLACEHOLDER.json:/inputs/scenario.json
+outputs:
+  - /outputs/result.json
+max_cost: 1
+max_runtime_minutes: 10
+${extra}
+`);
+    return yamlPath;
+  }
+
+  it('submits one deployment per file in the fan-out directory, in parallel', async () => {
+    mkdirSync(join(dir, 'scenarios'));
+    writeFileSync(join(dir, 'scenarios', 's0.json'), '{}');
+    writeFileSync(join(dir, 'scenarios', 's1.json'), '{}');
+    writeFileSync(join(dir, 'scenarios', 'PLACEHOLDER.json'), '{}'); // satisfies inputs: parse; overridden per task
+    const yamlPath = writeFanOutYaml(dir);
+
+    let callCount = 0;
+    const capturedBodies = [];
+    fallback.callWithFallback.mockImplementation((endpoint, callOpts, buildBody) => {
+      callCount += 1;
+      capturedBodies.push(buildBody());
+      return Promise.resolve({
+        deployment_id: `dep-${callCount}`, receipt_id: `rcpt-${callCount}`, gpu_type: 'RTX_4090',
+        gpu_count: 1, cost_per_hour: 0.2, provider: 'runpod', tier: '1', status: 'running',
+      });
+    });
+    api.callApi.mockImplementation((path) => {
+      if (path.startsWith('/deployments/')) {
+        return Promise.resolve({ status: 'succeeded', teardown_ok: 'ok', runtime_seconds: 3, accrued_cost_usd: 0.01 });
+      }
+      return Promise.resolve({});
+    });
+    api.uploadBlob.mockResolvedValue({ code_uri: 'https://cdn.example.com/inputs.tar.gz', upload_id: 'up_1' });
+
+    await batchCommand(config, ['run', yamlPath, '--fan-out', join(dir, 'scenarios')], chalk);
+
+    // 3 files in scenarios/ (PLACEHOLDER.json, s0.json, s1.json), one deployment each.
+    expect(callCount).toBe(3);
+    expect(store.addReceipt).toHaveBeenCalledTimes(3);
+    const names = capturedBodies.map(b => b.name);
+    expect(names.every(n => n.startsWith('screen-'))).toBe(true);
+    expect(new Set(names).size).toBe(3); // distinct per-file names
+    expect(capturedBodies[0].env.BADGR_FANOUT_INPUT).toBeDefined();
+    expect(store.addReceipt).toHaveBeenCalledWith(expect.objectContaining({ workloadShape: 'fan-out' }));
+    expect(process.exitCode).toBeUndefined();
+  });
+
+  it('rejects --fan-out when workload.yml declares more than one input', async () => {
+    mkdirSync(join(dir, 'scenarios'));
+    writeFileSync(join(dir, 'scenarios', 's0.json'), '{}');
+    const yamlPath = join(dir, 'workload.yml');
+    writeFileSync(yamlPath, `
+name: multi-input
+image: busybox
+command: [echo, hi]
+inputs:
+  - ./a.txt:/inputs/a.txt
+  - ./b.txt:/inputs/b.txt
+max_cost: 1
+max_runtime_minutes: 5
+`);
+    writeFileSync(join(dir, 'a.txt'), 'x');
+    writeFileSync(join(dir, 'b.txt'), 'x');
+
+    await batchCommand(config, ['run', yamlPath, '--fan-out', join(dir, 'scenarios')], chalk);
+    expect(process.exitCode).toBe(1);
+    expect(fallback.callWithFallback).not.toHaveBeenCalled();
+  });
+
+  it('rejects a --fan-out path that does not exist', async () => {
+    const yamlPath = writeFanOutYaml(dir);
+    await batchCommand(config, ['run', yamlPath, '--fan-out', join(dir, 'does-not-exist')], chalk);
+    expect(process.exitCode).toBe(1);
+    expect(fallback.callWithFallback).not.toHaveBeenCalled();
+  });
+
+  it('--dry-run with --fan-out never submits any task — same regression as the non-fan-out case', async () => {
+    mkdirSync(join(dir, 'scenarios'));
+    writeFileSync(join(dir, 'scenarios', 's0.json'), '{}');
+    writeFileSync(join(dir, 'scenarios', 's1.json'), '{}');
+    writeFileSync(join(dir, 'scenarios', 'PLACEHOLDER.json'), '{}');
+    const yamlPath = writeFanOutYaml(dir);
+
+    await batchCommand(config, ['run', yamlPath, '--fan-out', join(dir, 'scenarios'), '--dry-run'], chalk);
+
+    expect(process.exitCode).toBeUndefined();
+    expect(fallback.callWithFallback).not.toHaveBeenCalled();
+    expect(api.uploadBlob).not.toHaveBeenCalled();
+    expect(store.addReceipt).not.toHaveBeenCalled();
+  });
+
+  it('rejects an empty --fan-out directory', async () => {
+    mkdirSync(join(dir, 'empty'));
+    const yamlPath = writeFanOutYaml(dir);
+    await batchCommand(config, ['run', yamlPath, '--fan-out', join(dir, 'empty')], chalk);
+    expect(process.exitCode).toBe(1);
+    expect(fallback.callWithFallback).not.toHaveBeenCalled();
+  });
+
+  it('reports a non-zero exit code when at least one fan-out task fails', async () => {
+    mkdirSync(join(dir, 'scenarios'));
+    writeFileSync(join(dir, 'scenarios', 's0.json'), '{}');
+    writeFileSync(join(dir, 'scenarios', 's1.json'), '{}');
+    const yamlPath = writeFanOutYaml(dir);
+
+    const { monitorBatchJob } = await import('../src/batch.js');
+    let monitorCall = 0;
+    monitorBatchJob.mockImplementation(() => {
+      monitorCall += 1;
+      return Promise.resolve(
+        monitorCall === 1
+          ? { status: 'failed', exitCode: 1, runtimeMs: 100, reason: 'infrastructure' }
+          : { status: 'succeeded', exitCode: 0, runtimeMs: 100, reason: 'complete' },
+      );
+    });
+
+    let depCall = 0;
+    fallback.callWithFallback.mockImplementation((endpoint, callOpts, buildBody) => {
+      depCall += 1;
+      return Promise.resolve({
+        deployment_id: `dep-${depCall}`, receipt_id: `rcpt-${depCall}`, gpu_type: 'RTX_4090',
+        gpu_count: 1, cost_per_hour: 0.2, provider: 'runpod', tier: '1', status: 'running',
+      });
+    });
+    api.callApi.mockImplementation((path) => {
+      if (path.startsWith('/deployments/dep-1')) return Promise.resolve({ status: 'failed', teardown_ok: 'ok' });
+      if (path.startsWith('/deployments/')) return Promise.resolve({ status: 'succeeded', teardown_ok: 'ok' });
+      return Promise.resolve({});
+    });
+    api.uploadBlob.mockResolvedValue({ code_uri: 'https://cdn.example.com/inputs.tar.gz', upload_id: 'up_1' });
+
+    await batchCommand(config, ['run', yamlPath, '--fan-out', join(dir, 'scenarios')], chalk);
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('prints a ready-to-copy --only rerun command listing the failed inputs', async () => {
+    mkdirSync(join(dir, 'scenarios'));
+    writeFileSync(join(dir, 'scenarios', 's0.json'), '{}');
+    writeFileSync(join(dir, 'scenarios', 's1.json'), '{}');
+    const yamlPath = writeFanOutYaml(dir);
+
+    const { monitorBatchJob } = await import('../src/batch.js');
+    monitorBatchJob
+      .mockResolvedValueOnce({ status: 'failed', exitCode: 1, runtimeMs: 100, reason: 'infrastructure' })
+      .mockResolvedValueOnce({ status: 'succeeded', exitCode: 0, runtimeMs: 100, reason: 'complete' });
+    let depCall = 0;
+    fallback.callWithFallback.mockImplementation(() => {
+      depCall += 1;
+      return Promise.resolve({
+        deployment_id: `dep-${depCall}`, receipt_id: `rcpt-${depCall}`, gpu_type: 'RTX_4090',
+        gpu_count: 1, cost_per_hour: 0.2, provider: 'runpod', tier: '1', status: 'running',
+      });
+    });
+    api.callApi.mockImplementation((path) => {
+      if (path.startsWith('/deployments/dep-1')) return Promise.resolve({ status: 'failed', teardown_ok: 'ok' });
+      if (path.startsWith('/deployments/')) return Promise.resolve({ status: 'succeeded', teardown_ok: 'ok' });
+      return Promise.resolve({});
+    });
+    api.uploadBlob.mockResolvedValue({ code_uri: 'https://cdn.example.com/inputs.tar.gz', upload_id: 'up_1' });
+
+    const logs = [];
+    const origLog = console.log;
+    console.log = (...args) => { logs.push(args.join(' ')); };
+    // --max-concurrency 1 makes submit/monitor order deterministic (s0 fully
+    // completes before s1 starts), so the first mocked monitor result (failed)
+    // is guaranteed to land on s0 rather than depending on scheduling order.
+    await batchCommand(config, ['run', yamlPath, '--fan-out', join(dir, 'scenarios'), '--max-concurrency', '1'], chalk);
+    console.log = origLog;
+
+    expect(process.exitCode).toBe(1);
+    expect(logs.some(l => l.includes('--only s0.json'))).toBe(true);
+  });
+
+  it('--only restricts the fan-out to the named files', async () => {
+    mkdirSync(join(dir, 'scenarios'));
+    writeFileSync(join(dir, 'scenarios', 's0.json'), '{}');
+    writeFileSync(join(dir, 'scenarios', 's1.json'), '{}');
+    writeFileSync(join(dir, 'scenarios', 's2.json'), '{}');
+    const yamlPath = writeFanOutYaml(dir);
+
+    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.2, provider: 'runpod', tier: '1', status: 'running',
+      });
+    });
+    api.callApi.mockResolvedValue({ status: 'succeeded', teardown_ok: 'ok', runtime_seconds: 1, accrued_cost_usd: 0.01 });
+    api.uploadBlob.mockResolvedValue({ code_uri: 'https://cdn.example.com/inputs.tar.gz', upload_id: 'up_1' });
+
+    await batchCommand(config, ['run', yamlPath, '--fan-out', join(dir, 'scenarios'), '--only', 's0.json,s2.json'], chalk);
+
+    expect(callCount).toBe(2); // not 3 — s1.json excluded
+    expect(process.exitCode).toBeUndefined();
+  });
+
+  it('--only rejects a filename that does not exist in the fan-out directory', async () => {
+    mkdirSync(join(dir, 'scenarios'));
+    writeFileSync(join(dir, 'scenarios', 's0.json'), '{}');
+    const yamlPath = writeFanOutYaml(dir);
+
+    await batchCommand(config, ['run', yamlPath, '--fan-out', join(dir, 'scenarios'), '--only', 'does-not-exist.json'], chalk);
+
+    expect(process.exitCode).toBe(1);
+    expect(fallback.callWithFallback).not.toHaveBeenCalled();
+  });
+
+  it('rejects a non-positive --max-concurrency before touching the network', async () => {
+    mkdirSync(join(dir, 'scenarios'));
+    writeFileSync(join(dir, 'scenarios', 's0.json'), '{}');
+    const yamlPath = writeFanOutYaml(dir);
+
+    await batchCommand(config, ['run', yamlPath, '--fan-out', join(dir, 'scenarios'), '--max-concurrency', '0'], chalk);
+
+    expect(process.exitCode).toBe(1);
+    expect(fallback.callWithFallback).not.toHaveBeenCalled();
+  });
+
+  it('never exceeds --max-concurrency in-flight submissions', async () => {
+    mkdirSync(join(dir, 'scenarios'));
+    for (let i = 0; i < 6; i++) writeFileSync(join(dir, 'scenarios', `s${i}.json`), '{}');
+    const yamlPath = writeFanOutYaml(dir);
+
+    let inFlight = 0;
+    let maxInFlight = 0;
+    let depCall = 0;
+    fallback.callWithFallback.mockImplementation(async () => {
+      depCall += 1;
+      inFlight++;
+      maxInFlight = Math.max(maxInFlight, inFlight);
+      await new Promise(r => setTimeout(r, 5));
+      return {
+        deployment_id: `dep-${depCall}`, receipt_id: `rcpt-${depCall}`, gpu_type: 'RTX_4090',
+        gpu_count: 1, cost_per_hour: 0.2, provider: 'runpod', tier: '1', status: 'running',
+      };
+    });
+    const { monitorBatchJob } = await import('../src/batch.js');
+    monitorBatchJob.mockImplementation(async () => {
+      await new Promise(r => setTimeout(r, 5));
+      inFlight--;
+      return { status: 'succeeded', exitCode: 0, runtimeMs: 5, reason: 'complete' };
+    });
+    api.callApi.mockResolvedValue({ status: 'succeeded', teardown_ok: 'ok', runtime_seconds: 1, accrued_cost_usd: 0.01 });
+    api.uploadBlob.mockResolvedValue({ code_uri: 'https://cdn.example.com/inputs.tar.gz', upload_id: 'up_1' });
+
+    await batchCommand(config, ['run', yamlPath, '--fan-out', join(dir, 'scenarios'), '--max-concurrency', '2'], chalk);
+
+    expect(maxInFlight).toBeLessThanOrEqual(2);
+    expect(depCall).toBe(6);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // badgr batch artifacts — clear, actionable failure messages
 // ---------------------------------------------------------------------------

package/tests/browser.test.js

@@ -0,0 +1,51 @@
+/**
+ * Regression test for a real command-injection vector: openBrowser used to
+ * build a shell command via string interpolation (`execSync(\`open "${url}"\`)`).
+ * url is not always a local constant — onboarding.js passes
+ * session.login_url, a backend API response — so a response containing
+ * shell metacharacters (e.g. a double quote followed by a command) would
+ * have executed arbitrary shell commands on the user's machine. Every test
+ * that exercises onboarding.js mocks browser.js entirely, so this file
+ * itself was never actually run by any existing test.
+ *
+ * Fixed with execFileSync (argv array, no shell) — this test asserts the
+ * fix directly: no shell ever sees url as a string to parse.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mockExecFileSync = vi.fn();
+vi.mock('child_process', () => ({ execFileSync: (...args) => mockExecFileSync(...args) }));
+
+const { openBrowser } = await import('../src/browser.js');
+
+describe('openBrowser', () => {
+  const maliciousUrl = 'https://example.com/"; touch /tmp/pwned; echo "';
+
+  beforeEach(() => {
+    mockExecFileSync.mockReset();
+  });
+
+  it('darwin: passes the URL as a single argv element, never a shell string', () => {
+    vi.spyOn(process, 'platform', 'get').mockReturnValue('darwin');
+    openBrowser(maliciousUrl);
+    expect(mockExecFileSync).toHaveBeenCalledWith('open', [maliciousUrl]);
+  });
+
+  it('linux: passes the URL as a single argv element, never a shell string', () => {
+    vi.spyOn(process, 'platform', 'get').mockReturnValue('linux');
+    openBrowser(maliciousUrl);
+    expect(mockExecFileSync).toHaveBeenCalledWith('xdg-open', [maliciousUrl]);
+  });
+
+  it('win32: passes the URL as a single argv element, never a shell string', () => {
+    vi.spyOn(process, 'platform', 'get').mockReturnValue('win32');
+    openBrowser(maliciousUrl);
+    expect(mockExecFileSync).toHaveBeenCalledWith('cmd', ['/c', 'start', '', maliciousUrl]);
+  });
+
+  it('never throws even if execFileSync fails — caller always has the printed URL as fallback', () => {
+    vi.spyOn(process, 'platform', 'get').mockReturnValue('darwin');
+    mockExecFileSync.mockImplementation(() => { throw new Error('no such command'); });
+    expect(() => openBrowser(maliciousUrl)).not.toThrow();
+  });
+});

package/tests/capacity.test.js

@@ -0,0 +1,68 @@
+/**
+ * badgr capacity — price-cap behavior
+ *
+ * Regression coverage: `badgr capacity` used to silently default to
+ * --max-price 10 and print misleading "under $10.00/hr" messaging even
+ * though the user never asked for a cap. It should now omit max_price
+ * entirely unless the user passes --max-price, and only mention a price
+ * ceiling in output when one was actually requested.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('../src/api.js', () => ({
+  callApi: vi.fn(),
+}));
+
+import * as api from '../src/api.js';
+import { capacityCommand } from '../src/commands/capacity.js';
+
+const config = { apiKey: 'test-key', baseUrl: 'https://api.test' };
+const chalk = new Proxy({}, { get: () => (s) => s });
+
+function urlParams(callIndex = 0) {
+  const url = api.callApi.mock.calls[callIndex][0];
+  return new URLSearchParams(url.split('?')[1] ?? '');
+}
+
+describe('capacityCommand price cap', () => {
+  beforeEach(() => {
+    api.callApi.mockReset();
+  });
+
+  it('omits max_price from /capacity/auto when --max-price is not passed', async () => {
+    api.callApi.mockResolvedValueOnce({ gpu: 'RTX_4090', region: 'US', price: 0.17 });
+    await capacityCommand(config, [], chalk);
+    expect(urlParams().has('max_price')).toBe(false);
+  });
+
+  it('sends max_price on /capacity/auto when --max-price is passed', async () => {
+    api.callApi.mockResolvedValueOnce({ gpu: 'RTX_4090', region: 'US', price: 0.17 });
+    await capacityCommand(config, ['--max-price', '5'], chalk);
+    expect(urlParams().get('max_price')).toBe('5');
+  });
+
+  it('omits max_price from /capacity/suggestions when --max-price is not passed', async () => {
+    api.callApi.mockResolvedValueOnce({ matches: [], alternatives: [] });
+    await capacityCommand(config, ['--gpu', '5090'], chalk);
+    expect(urlParams().has('max_price')).toBe(false);
+  });
+
+  it('does not mention a price ceiling in the no-match message when none was requested', async () => {
+    api.callApi.mockResolvedValueOnce({ matches: [], alternatives: [] });
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    await capacityCommand(config, ['--gpu', '5090'], chalk);
+    const output = logSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+    logSpy.mockRestore();
+    expect(output).toContain('No 5090 available right now.');
+    expect(output).not.toContain('under $');
+  });
+
+  it('mentions the price ceiling in the no-match message when --max-price was passed', async () => {
+    api.callApi.mockResolvedValueOnce({ matches: [], alternatives: [] });
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    await capacityCommand(config, ['--gpu', '5090', '--max-price', '10'], chalk);
+    const output = logSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+    logSpy.mockRestore();
+    expect(output).toContain('under $10.00/hr');
+  });
+});

package/tests/commands.test.js

@@ -95,6 +95,42 @@ describe('parseRunArgs', () => {
     expect(flags.minVram).toBe(40);
   });
 
+  it('parses --gpu-memory as a GB-parsed alias for --min-vram', () => {
+    const { flags } = parseRunArgs(['python', 'job.py', '--gpu-memory', '24GB']);
+    expect(flags.minVram).toBe(24);
+  });
+
+  it('--gpu-memory accepts a bare number (assumed GB)', () => {
+    const { flags } = parseRunArgs(['python', 'job.py', '--gpu-memory', '40']);
+    expect(flags.minVram).toBe(40);
+  });
+
+  it('parses --cpu as an integer core count', () => {
+    const { flags } = parseRunArgs(['python', 'job.py', '--cpu', '16']);
+    expect(flags.cpu).toBe(16);
+  });
+
+  it('parses --memory with a GB/MB suffix into a GB float', () => {
+    const { flags: gb } = parseRunArgs(['python', 'job.py', '--memory', '64GB']);
+    expect(gb.memory).toBe(64);
+    const { flags: mb } = parseRunArgs(['python', 'job.py', '--memory', '65536MB']);
+    expect(mb.memory).toBeCloseTo(64);
+  });
+
+  it('--cpu, --memory, --gpu-memory can all be combined', () => {
+    const { flags } = parseRunArgs(['python', 'job.py', '--cpu', '16', '--memory', '64GB', '--gpu-memory', '24GB']);
+    expect(flags.cpu).toBe(16);
+    expect(flags.memory).toBe(64);
+    expect(flags.minVram).toBe(24);
+  });
+
+  it('parses --no-gpu', () => {
+    const { flags } = parseRunArgs(['python', 'sim.py', '--no-gpu', '--cpu', '16', '--memory', '64GB']);
+    expect(flags.noGpu).toBe(true);
+    expect(flags.cpu).toBe(16);
+    expect(flags.memory).toBe(64);
+  });
+
   it('-- separator: badgr flags before --, command argv after', () => {
     const { flags, commandArgv, positional } = parseRunArgs([
       '--gpu', 'RTX_4090', '--image', 'node:20', '--max-cost', '1', '--',
@@ -371,3 +407,11 @@ describe('promptFallback output', () => {
     expect(joined).toContain('1.25');
   });
 });
+
+describe('old agent-positional run path (removed)', () => {
+  it('no longer exports isAgentRun/buildAgentRun from run.js', async () => {
+    const mod = await import('../src/commands/run.js');
+    expect(mod.isAgentRun).toBeUndefined();
+    expect(mod.buildAgentRun).toBeUndefined();
+  });
+});

package/tests/connect.test.js

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

@@ -34,7 +34,7 @@ const chalk = {
   cyan:   s => s,
 };
 
-function makeStoppedDep(runtimeSeconds, costPerHour = 1.00) {
+function makeStoppedDep(runtimeSeconds, costPerHour = 1.00, overrides = {}) {
   const now = Date.now() / 1000;
   return {
     deployment_id: 'dep-test-001',
@@ -42,6 +42,8 @@ function makeStoppedDep(runtimeSeconds, costPerHour = 1.00) {
     cost_per_hour: costPerHour,
     stopped_at:    now,
     started_at:    now - runtimeSeconds,
+    teardown_ok:   'ok',
+    ...overrides,
   };
 }
 
@@ -114,6 +116,26 @@ describe('receipt is recorded', () => {
   });
 });
 
+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'));