badgr-cli 1.0.46 → 1.0.47

package/src/commands/run.js

@@ -3,7 +3,7 @@ import path from 'path';
 import os from 'os';
 import { createWriteStream } from 'fs';
 import { requireApiKey } from '../config.js';
-import { callApi, terminateDeployment } from '../api.js';
+import { callApi, terminateDeployment, uploadBlob } from '../api.js';
 import { addReceipt, updateReceipt, generateReceiptId } from '../store.js';
 import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
 import { formatCliError } from '../errors.js';
@@ -428,32 +428,16 @@ export async function _uploadCodeZip(config, dirPath, chalk) {
   process.stdout.write(chalk.dim(` ${sizeMb} MB\n`));
 
   process.stdout.write(chalk.dim('  Uploading project...'));
-  // POST zip directly to the Badgr backend — no S3, no presigned URLs.
-  // Built-in FormData/Blob/fetch (Node >=18) keep the CLI dependency-free for
-  // multipart uploads; fetch sets the multipart boundary header automatically.
   const fileData = fs.readFileSync(tmpFile);
-  const form = new FormData();
-  form.append('file', new Blob([fileData], { type: 'application/zip' }), 'project.zip');
-
-  const baseUrl = config.baseUrl.replace(/\/v1\/?$/, '');
   let uploadResp;
   try {
-    uploadResp = await fetch(`${baseUrl}/v1/uploads`, {
-      method: 'POST',
-      body: form,
-      headers: { 'Authorization': `Bearer ${config.apiKey}` },
-    });
+    uploadResp = await uploadBlob(config, { data: fileData, filename: 'project.zip', contentType: 'application/zip' });
   } finally {
     fs.unlinkSync(tmpFile);
   }
 
-  if (!uploadResp.ok) {
-    const text = await uploadResp.text().catch(() => '');
-    throw new Error(`Upload failed: ${uploadResp.status} ${uploadResp.statusText}${text ? ` — ${text}` : ''}`);
-  }
-  const { code_uri: codeUri } = await uploadResp.json();
   process.stdout.write(chalk.dim(' done\n'));
-  return codeUri;
+  return uploadResp.code_uri;
 }
 
 export async function runCommand(config, args, chalk) {

package/src/commands/train.js

@@ -11,6 +11,7 @@ import { addReceipt, updateReceipt, generateReceiptId } from '../store.js';
 import { normalizeTier, callWithFallback } from '../fallback.js';
 import { monitorBatchJob, fmtRuntime } from '../batch.js';
 import { pollJobUntilTerminal, renderJobClosingBlock } from '../progress.js';
+import { uploadBlob } from '../api.js';
 
 const MAX_CONFIG_B = 512 * 1024; // 512 KB config limit
 
@@ -116,6 +117,7 @@ export function parseTrainLoraArgs(args) {
     if (a === '--max-runtime')  { flags.maxRuntime = parseFloat(args[++i]); i++; continue; }
     if (a === '--tier')         { flags.tier = args[++i]; i++; continue; }
     if (a === '--gpu-type')     { flags.gpuType = args[++i]; i++; continue; }
+    if (a === '--resume')       { flags.resume = args[++i]; i++; continue; }
     if (a === '--dry-run')      { flags.dryRun = true; i++; continue; }
     i++;
   }
@@ -138,7 +140,8 @@ export async function trainLoraCommand(config, args, chalk) {
     console.error(chalk.dim('  Dataset sources:'));
     console.error(chalk.dim('    --dataset ./train.jsonl        local file (uploaded first)'));
     console.error(chalk.dim('    --dataset https://...          direct URL'));
-    console.error(chalk.dim('    --file-id up_abc123            Badgr upload ID\n'));
+    console.error(chalk.dim('    --file-id up_abc123            Badgr upload ID'));
+    console.error(chalk.dim('  --resume <checkpoint-url>        continue training from a prior job\'s checkpoint\n'));
     process.exitCode = 1;
     return;
   }
@@ -164,6 +167,7 @@ export async function trainLoraCommand(config, args, chalk) {
     }
     if (flags.maxCost)    console.log(`  ${chalk.bold('Max cost:')}     $${flags.maxCost}`);
     console.log(`  ${chalk.bold('Max runtime:')}  ${flags.maxRuntime ?? 240}min`);
+    if (flags.resume)    console.log(`  ${chalk.bold('Resume from:')}  ${flags.resume}`);
     console.log(chalk.dim('\n  Remove --dry-run to submit (local file datasets are uploaded first).\n'));
     return;
   }
@@ -177,36 +181,58 @@ export async function trainLoraCommand(config, args, chalk) {
   } else if (flags.dataset && (flags.dataset.startsWith('http://') || flags.dataset.startsWith('https://') || flags.dataset.startsWith('s3://'))) {
     input.dataset_url = flags.dataset;
   } else if (flags.dataset) {
-    // Local file — upload first
-    const { createReadStream, statSync } = await import('fs');
+    // Local file — upload first (skipping re-upload if content is unchanged
+    // from a prior run, per the local upload cache).
     if (!existsSync(flags.dataset)) {
       console.error(chalk.red(`\n  ✗ Dataset file not found: ${flags.dataset}\n`));
       process.exitCode = 1;
       return;
     }
-    console.log(chalk.dim(`\n  Uploading dataset ${flags.dataset}…`));
+    const { createHash } = await import('crypto');
     const { readFileSync: readDs } = await import('fs');
+    const { getCachedUploadId, setCachedUploadId } = await import('../store.js');
     const fileData = readDs(flags.dataset);
-    const form = new FormData();
-    form.append('file', new Blob([fileData]), flags.dataset.split('/').pop() || 'dataset.jsonl');
-    const baseUrl = config.baseUrl.replace(/\/v1\/?$/, '');
-    const uploadRes = await fetch(`${baseUrl}/v1/uploads`, {
-      method: 'POST',
-      body: form,
-      headers: { Authorization: `Bearer ${config.apiKey}` },
-    });
-    if (!uploadRes.ok) {
-      const text = await uploadRes.text().catch(() => '');
-      console.error(chalk.red(`\n  ✗ Dataset upload failed: ${uploadRes.status}${text ? ` — ${text}` : ''}\n`));
-      process.exitCode = 1;
-      return;
+
+    // .jsonl datasets are the common case — catch a malformed file before
+    // spending an upload + a GPU on it rather than failing mid-training.
+    if (flags.dataset.endsWith('.jsonl')) {
+      const lines = fileData.toString('utf8').split('\n').filter(l => l.trim());
+      const badLine = lines.findIndex(l => { try { JSON.parse(l); return false; } catch { return true; } });
+      if (badLine !== -1) {
+        console.error(chalk.red(`\n  ✗ Dataset is not valid JSONL — line ${badLine + 1} is not valid JSON.\n`));
+        process.exitCode = 1;
+        return;
+      }
+      if (lines.length === 0) {
+        console.error(chalk.red(`\n  ✗ Dataset file ${flags.dataset} is empty.\n`));
+        process.exitCode = 1;
+        return;
+      }
+    }
+
+    const contentHash = createHash('sha256').update(fileData).digest('hex');
+    const cachedUploadId = getCachedUploadId(contentHash);
+    if (cachedUploadId) {
+      input.dataset_file_id = cachedUploadId;
+      console.log(chalk.dim(`\n  Dataset unchanged since last run — reusing upload ${cachedUploadId} (no re-upload)`));
+    } else {
+      console.log(chalk.dim(`\n  Uploading dataset ${flags.dataset}…`));
+      let uploadResp;
+      try {
+        uploadResp = await uploadBlob(config, { data: fileData, filename: flags.dataset.split('/').pop() || 'dataset.jsonl' });
+      } catch (err) {
+        console.error(chalk.red(`\n  ✗ Dataset upload failed: ${err.message}\n`));
+        process.exitCode = 1;
+        return;
+      }
+      input.dataset_file_id = uploadResp.upload_id;
+      setCachedUploadId(contentHash, uploadResp.upload_id, { file: flags.dataset });
+      console.log(chalk.dim(`  Uploaded: ${uploadResp.upload_id}`));
     }
-    const uploadResp = await uploadRes.json();
-    input.dataset_file_id = uploadResp.upload_id;
-    console.log(chalk.dim(`  Uploaded: ${uploadResp.upload_id}`));
   }
 
   if (flags.gpuType) input.gpu_type = flags.gpuType;
+  if (flags.resume) input.resume_from_checkpoint_url = flags.resume;
 
   const rcptId = generateReceiptId();
   const maxRuntime = flags.maxRuntime ?? 240;
@@ -215,7 +241,9 @@ export async function trainLoraCommand(config, args, chalk) {
   console.log(`  ${chalk.bold('Base model:')} ${flags.baseModel}`);
   console.log(`  ${chalk.bold('Preset:')}     ${input.config_preset}`);
   console.log(`  ${chalk.bold('Max cost:')}   $${flags.maxCost}`);
-  console.log(`  ${chalk.bold('Max runtime:')} ${maxRuntime} min\n`);
+  console.log(`  ${chalk.bold('Max runtime:')} ${maxRuntime} min`);
+  if (flags.resume) console.log(`  ${chalk.bold('Resuming from:')} ${flags.resume}`);
+  console.log();
 
   let job;
   try {

package/src/store.js

@@ -106,3 +106,30 @@ export function findReceipt(idOrJobId, storeFile = STORE_FILE) {
   const { receipts } = loadStore(storeFile);
   return receipts.find(r => r.receiptId === idOrJobId || r.job_id === idOrJobId) ?? null;
 }
+
+// ---------------------------------------------------------------------------
+// Upload cache — content-hash → upload_id, so re-running the same dataset
+// (e.g. `badgr train lora` reruns, iterating on a config) skips re-uploading
+// unchanged files. Persisted to ~/.badgr/upload-cache.json.
+// ---------------------------------------------------------------------------
+export const UPLOAD_CACHE_FILE = join(CONFIG_DIR, 'upload-cache.json');
+
+export function loadUploadCache(cacheFile = UPLOAD_CACHE_FILE) {
+  if (!existsSync(cacheFile)) return {};
+  try {
+    return JSON.parse(readFileSync(cacheFile, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+export function getCachedUploadId(contentHash, cacheFile = UPLOAD_CACHE_FILE) {
+  return loadUploadCache(cacheFile)[contentHash]?.uploadId ?? null;
+}
+
+export function setCachedUploadId(contentHash, uploadId, meta = {}, cacheFile = UPLOAD_CACHE_FILE) {
+  const cache = loadUploadCache(cacheFile);
+  cache[contentHash] = { uploadId, cachedAt: new Date().toISOString(), ...meta };
+  mkdirSync(dirname(cacheFile), { recursive: true });
+  writeFileSync(cacheFile, JSON.stringify(cache, null, 2));
+}

package/src/workloadSpec.js

@@ -0,0 +1,126 @@
+/**
+ * workload.yml parsing/validation for `badgr batch`.
+ *
+ * Deliberately generic — not robotics-specific. Physical-AI is just one
+ * workload that happens to use this schema, not a special case of it.
+ *
+ * Schema:
+ *   name: <string>                    required
+ *   image: <string>                   required
+ *   command: [<string>, ...]          required
+ *   inputs: ["<local>:<container abs path>", ...]   optional
+ *   outputs: ["<container abs path>", ...]          optional
+ *   env: {KEY: value}                 optional
+ *   max_cost: <number>                required
+ *   max_runtime_minutes: <number>     required
+ *   success_metric:                   optional
+ *     file: <container abs path>
+ *     key: <string>
+ *     higher_is_better: <bool>
+ */
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import yaml from 'js-yaml';
+
+export class WorkloadSpecError extends Error {}
+
+function isNonEmptyString(v) {
+  return typeof v === 'string' && v.length > 0;
+}
+
+/**
+ * Parse a single "local:containerPath" inputs entry. containerPath must be
+ * an absolute path (workload.yml is container-path-oriented for inputs);
+ * splitting on the *last* colon so Windows-style local paths with a drive
+ * letter don't break parsing.
+ */
+export function parseInputEntry(entry) {
+  const idx = entry.lastIndexOf(':');
+  if (idx <= 0 || idx === entry.length - 1) {
+    throw new WorkloadSpecError(`inputs entry must be "<local path>:<container path>": ${entry}`);
+  }
+  const localPath = entry.slice(0, idx);
+  const containerPath = entry.slice(idx + 1);
+  if (!containerPath.startsWith('/')) {
+    throw new WorkloadSpecError(`inputs entry's container path must be absolute: ${entry}`);
+  }
+  return { localPath, containerPath };
+}
+
+export function validateWorkloadSpec(raw) {
+  const errors = [];
+  if (!isNonEmptyString(raw?.name)) errors.push('name is required');
+  if (!isNonEmptyString(raw?.image)) errors.push('image is required');
+  if (!Array.isArray(raw?.command) || raw.command.length === 0) errors.push('command is required and must be a non-empty list');
+  if (raw?.max_cost == null || typeof raw.max_cost !== 'number' || raw.max_cost <= 0) errors.push('max_cost is required and must be a positive number');
+  if (raw?.max_runtime_minutes == null || typeof raw.max_runtime_minutes !== 'number' || raw.max_runtime_minutes <= 0) errors.push('max_runtime_minutes is required and must be a positive number');
+
+  if (raw?.inputs !== undefined) {
+    if (!Array.isArray(raw.inputs)) {
+      errors.push('inputs must be a list');
+    } else {
+      for (const entry of raw.inputs) {
+        try { parseInputEntry(entry); } catch (err) { errors.push(err.message); }
+      }
+    }
+  }
+  if (raw?.outputs !== undefined) {
+    if (!Array.isArray(raw.outputs) || raw.outputs.some(p => typeof p !== 'string' || !p.startsWith('/'))) {
+      errors.push('outputs must be a list of absolute container paths');
+    }
+  }
+  if (raw?.success_metric !== undefined) {
+    const sm = raw.success_metric;
+    if (!sm || !isNonEmptyString(sm.file) || !sm.file.startsWith('/')) errors.push('success_metric.file must be an absolute container path');
+    if (!isNonEmptyString(sm?.key)) errors.push('success_metric.key is required when success_metric is set');
+    if (sm?.higher_is_better !== undefined && typeof sm.higher_is_better !== 'boolean') errors.push('success_metric.higher_is_better must be a boolean');
+  }
+  return errors;
+}
+
+/**
+ * Load and validate a workload.yml file. Returns a normalized spec object.
+ * Throws WorkloadSpecError with all validation problems on failure.
+ */
+export function parseWorkloadYaml(path) {
+  let raw;
+  try {
+    raw = readFileSync(path, 'utf8');
+  } catch (err) {
+    throw new WorkloadSpecError(`Could not read ${path}: ${err.message}`);
+  }
+  let doc;
+  try {
+    doc = yaml.load(raw);
+  } catch (err) {
+    throw new WorkloadSpecError(`Invalid YAML in ${path}: ${err.message}`);
+  }
+  const errors = validateWorkloadSpec(doc);
+  if (errors.length > 0) {
+    throw new WorkloadSpecError(`Invalid workload.yml:\n${errors.map(e => `  - ${e}`).join('\n')}`);
+  }
+
+  const baseDir = dirname(resolve(path));
+  const inputs = (doc.inputs ?? []).map(entry => {
+    const { localPath, containerPath } = parseInputEntry(entry);
+    return { localPath: resolve(baseDir, localPath), containerPath };
+  });
+
+  return {
+    name: doc.name,
+    image: doc.image,
+    command: doc.command,
+    inputs,
+    outputs: doc.outputs ?? [],
+    env: doc.env ?? {},
+    maxCost: doc.max_cost,
+    maxRuntimeMinutes: doc.max_runtime_minutes,
+    successMetric: doc.success_metric
+      ? {
+          file: doc.success_metric.file,
+          key: doc.success_metric.key,
+          higherIsBetter: doc.success_metric.higher_is_better ?? true,
+        }
+      : null,
+  };
+}

package/tests/api.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { callApi, listModels, chatCompletion, submitJob, getJobStatus, listReceipts, getReceipt, runJob, serveModel } from '../src/api.js';
+import { callApi, listModels, chatCompletion, submitJob, getJobStatus, listReceipts, getReceipt, runJob, serveModel, uploadBlob } from '../src/api.js';
 
 const mockConfig = { apiKey: 'sk-test', baseUrl: 'https://api.test/v1', defaultModel: 'llama-3' };
 
@@ -138,3 +138,31 @@ describe('serveModel', () => {
     expect(result.deployment_id).toBe('dep-xyz');
   });
 });
+
+describe('uploadBlob', () => {
+  it('POSTs multipart form data to /v1/uploads with Authorization, no manual Content-Type', async () => {
+    mockFetch({ upload_id: 'up_1', code_uri: 'https://api.test/v1/uploads/up_1/download?token=t' });
+    const result = await uploadBlob(mockConfig, { data: Buffer.from('hello'), filename: 'a.txt' });
+    const [url, init] = global.fetch.mock.calls[0];
+    expect(url).toBe('https://api.test/v1/uploads');
+    expect(init.method).toBe('POST');
+    expect(init.body).toBeInstanceOf(FormData);
+    expect(init.headers.Authorization).toBe('Bearer sk-test');
+    expect(init.headers['Content-Type']).toBeUndefined();
+    expect(result.upload_id).toBe('up_1');
+    expect(result.code_uri).toContain('up_1');
+  });
+
+  it('sets the Blob content type when contentType is given', async () => {
+    mockFetch({ upload_id: 'up_2', code_uri: 'https://x/up_2' });
+    await uploadBlob(mockConfig, { data: Buffer.from('x'), filename: 'a.tar.gz', contentType: 'application/gzip' });
+    const [, init] = global.fetch.mock.calls[0];
+    expect(init.body.get('file').type).toBe('application/gzip');
+  });
+
+  it('throws a clear error on a non-ok response', async () => {
+    mockFetch('boom', false, 500);
+    await expect(uploadBlob(mockConfig, { data: Buffer.from('x'), filename: 'a.txt' }))
+      .rejects.toThrow(/Upload failed: 500/);
+  });
+});