badgr-cli 1.0.42 → 1.0.44

package/src/progress.js

@@ -0,0 +1,42 @@
+// Shared staged-progress rendering used by `badgr serve` and `badgr run` —
+// numbered stage lines plus an in-place-redrawing status block, so neither
+// command spams repeated identical loading lines.
+
+export function stage(n, total, label) {
+  return `  [${n}/${total}] ${label}`;
+}
+
+export function stageDone(n, total, label) {
+  return `  [${n}/${total}] ${label} done`;
+}
+
+// Redraws a fixed-height status block in place instead of appending new
+// lines each tick — satisfies "no repeated identical loading lines" while
+// still showing live elapsed time. Returns the new line count to pass back
+// in as prevLineCount on the next call.
+export function writeBlock(prevLineCount, lines) {
+  if (prevLineCount > 0) process.stdout.write(`\x1b[${prevLineCount}A`);
+  for (const line of lines) process.stdout.write('\x1b[2K' + line + '\n');
+  return lines.length;
+}
+
+export function clearBlock(lineCount) {
+  if (lineCount <= 0) return;
+  process.stdout.write(`\x1b[${lineCount}A`);
+  for (let i = 0; i < lineCount; i++) process.stdout.write('\x1b[2K\n');
+  process.stdout.write(`\x1b[${lineCount}A`);
+}
+
+// The live block shown while a stage is in progress — same shape for both
+// `badgr serve` (deployment) and `badgr run` (job): elapsed time, a status
+// word, an *estimated* spend (never presented as confirmed while billing is
+// still live), and the exact commands to inspect logs or stop billing.
+export function renderLiveBlock(chalk, { stageLine, elapsedSec, statusWord, spend, id }) {
+  return [
+    chalk.dim(`${stageLine} ${elapsedSec}s elapsed`),
+    chalk.dim(`        Status: ${statusWord}`),
+    chalk.dim(`        Estimated spend: ~$${spend.toFixed(2)}`),
+    chalk.dim(`        Logs: badgr logs ${id}`),
+    chalk.dim(`        Stop billing: badgr down ${id}`),
+  ];
+}

package/tests/productized-dry-run.test.js

@@ -0,0 +1,141 @@
+/**
+ * --dry-run for the productized runner commands (badgr train lora, badgr comfyui batch).
+ *
+ * Both must preview the request (preset/workflow, GPU, cost) without calling the API,
+ * uploading files, or requiring an API key — mirroring the existing `badgr run --dry-run`
+ * and `badgr up --dry-run` behavior.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { trainLoraCommand, parseTrainLoraArgs } from '../src/commands/train.js';
+import { comfyBatchCommand, parseComfyBatchArgs } from '../src/commands/comfyui.js';
+
+vi.mock('../src/api.js', () => ({
+  callApi: vi.fn(),
+}));
+
+vi.mock('../src/store.js', () => ({
+  addReceipt:        vi.fn(),
+  generateReceiptId: vi.fn(() => 'rcpt-dry-001'),
+}));
+
+vi.mock('fs', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    readFileSync: vi.fn(),
+    existsSync:   vi.fn(),
+  };
+});
+
+import * as api   from '../src/api.js';
+import * as store from '../src/store.js';
+import * as fs    from 'fs';
+
+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' };
+
+beforeEach(() => {
+  process.exitCode = undefined;
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+  vi.spyOn(console, 'error').mockImplementation(() => {});
+  vi.clearAllMocks();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  process.exitCode = undefined;
+});
+
+describe('parseTrainLoraArgs', () => {
+  it('parses --dry-run', () => {
+    const flags = parseTrainLoraArgs(['--base-model', 'x', '--dry-run']);
+    expect(flags.dryRun).toBe(true);
+  });
+});
+
+describe('trainLoraCommand --dry-run', () => {
+  it('previews the job without calling the API or requiring an API key', async () => {
+    await trainLoraCommand({ apiKey: null, baseUrl: 'https://api.test/v1' }, [
+      '--base-model', 'mistralai/Mistral-7B-v0.1',
+      '--dataset', 'https://example.com/data.jsonl',
+      '--dry-run',
+    ], chalk);
+
+    expect(api.callApi).not.toHaveBeenCalled();
+    expect(store.addReceipt).not.toHaveBeenCalled();
+    expect(process.exitCode).toBeFalsy();
+    const logged = console.log.mock.calls.flat().join('\n');
+    expect(logged).toContain('Dry run');
+    expect(logged).toContain('mistralai/Mistral-7B-v0.1');
+    expect(logged).toContain('RTX_4090'); // default 'small' preset GPU
+  });
+
+  it('does not upload a local dataset file during --dry-run', async () => {
+    fs.existsSync.mockReturnValue(true);
+    fs.readFileSync.mockReturnValue('dummy');
+    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({ ok: true, json: async () => ({ upload_id: 'up_x' }) });
+
+    await trainLoraCommand(config, [
+      '--base-model', 'mistralai/Mistral-7B-v0.1',
+      '--dataset', './local.jsonl',
+      '--dry-run',
+    ], chalk);
+
+    expect(fetchSpy).not.toHaveBeenCalled();
+    fetchSpy.mockRestore();
+  });
+
+  it('still requires --base-model even with --dry-run', async () => {
+    await trainLoraCommand(config, ['--dry-run'], chalk);
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('flags an unknown preset instead of silently accepting it', async () => {
+    await trainLoraCommand(config, [
+      '--base-model', 'mistralai/Mistral-7B-v0.1',
+      '--preset', 'huge',
+      '--dry-run',
+    ], chalk);
+    const logged = console.log.mock.calls.flat().join('\n');
+    expect(logged).toContain('unknown');
+  });
+});
+
+describe('parseComfyBatchArgs', () => {
+  it('parses --dry-run', () => {
+    const flags = parseComfyBatchArgs(['--workflow', 'sdxl-basic', '--dry-run']);
+    expect(flags.dryRun).toBe(true);
+  });
+});
+
+describe('comfyBatchCommand --dry-run', () => {
+  it('previews the batch without calling the API or requiring an API key', async () => {
+    await comfyBatchCommand({ apiKey: null, baseUrl: 'https://api.test/v1' }, [
+      '--workflow', 'sdxl-basic',
+      '--prompt', 'a cat on a beach',
+      '--dry-run',
+    ], chalk);
+
+    expect(api.callApi).not.toHaveBeenCalled();
+    expect(store.addReceipt).not.toHaveBeenCalled();
+    expect(process.exitCode).toBeFalsy();
+    const logged = console.log.mock.calls.flat().join('\n');
+    expect(logged).toContain('Dry run');
+    expect(logged).toContain('sdxl-basic');
+    expect(logged).toContain('RTX_4090');
+  });
+
+  it('warns when the prompt count exceeds the 20-prompt cap', async () => {
+    const flags = { workflow: 'sdxl-basic', inlinePrompts: Array(21).fill('x') };
+    await comfyBatchCommand({ apiKey: null, baseUrl: 'https://api.test/v1' }, [
+      '--workflow', 'sdxl-basic',
+      ...Array(21).fill(['--prompt', 'x']).flat(),
+      '--dry-run',
+    ], chalk);
+    const logged = console.log.mock.calls.flat().join('\n');
+    expect(logged).toContain('exceeds the 20-prompt limit');
+  });
+});