badgr-cli 1.0.45 → 1.0.47

package/src/commands/rerun.js

@@ -0,0 +1,75 @@
+import { requireApiKey } from '../config.js';
+import { findDeployment, addDeployment, addReceipt, generateReceiptId } from '../store.js';
+import { rerunDeployment } from '../api.js';
+
+/**
+ * badgr rerun <deployment-id|name>
+ *
+ * Replays a previous job or endpoint with its exact original spec — same
+ * image, command, env vars, GPU, and cost/runtime caps. Works for one-off
+ * jobs (unlike `badgr restart`, which is endpoint-only) and never tears
+ * down the source deployment. Always creates a new deployment_id.
+ */
+export async function rerunCommand(config, args, chalk) {
+  const idOrName = args.find(a => !a.startsWith('--'));
+
+  if (!idOrName) {
+    console.error(chalk.red('Usage: badgr rerun <deployment-id|name>'));
+    return;
+  }
+
+  requireApiKey(config);
+
+  const localDep     = findDeployment(idOrName);
+  const deploymentId = localDep?.id ?? idOrName;
+
+  process.stdout.write(chalk.dim(`  Replaying ${deploymentId}...`));
+
+  let dep;
+  try {
+    dep = await rerunDeployment(config, deploymentId);
+  } catch (err) {
+    process.stdout.write('\n');
+    console.error(chalk.red(`\n  ✗ Could not rerun deployment: ${err.message}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  process.stdout.write('\n');
+
+  addDeployment({
+    id:          dep.deployment_id,
+    name:        dep.name,
+    type:        dep.workload_type,
+    model:       dep.model,
+    gpu:         dep.gpu_type,
+    count:       dep.gpu_count,
+    status:      dep.status,
+    endpointUrl: dep.endpoint_url || dep.openai_base_url,
+    receiptId:   dep.receipt_id,
+    createdAt:   new Date().toISOString(),
+    costPerHour: dep.cost_per_hour || 0,
+    providerRoute: dep.provider ?? null,
+    tier:          dep.tier ?? null,
+  });
+
+  const rcptId = dep.receipt_id || generateReceiptId();
+  addReceipt({
+    receiptId:    rcptId,
+    action:       'badgr rerun',
+    deploymentId: dep.deployment_id,
+    gpu:          dep.gpu_type,
+    status:       dep.status,
+    rerunOf:      deploymentId,
+    createdAt:    new Date().toISOString(),
+  });
+
+  const endpointUrl = dep.endpoint_url || dep.openai_base_url;
+  console.log(chalk.green('\n  ✓ Rerun submitted\n'));
+  console.log(`  ${chalk.bold('Replayed from:')}  ${chalk.dim(deploymentId)}`);
+  console.log(`  ${chalk.bold('New deployment:')} ${chalk.cyan(dep.deployment_id)}`);
+  if (endpointUrl) console.log(`  ${chalk.bold('Base URL:')}        ${chalk.cyan(endpointUrl)}`);
+  console.log(`  ${chalk.bold('Status:')}          badgr status ${dep.deployment_id}`);
+  console.log(`  ${chalk.bold('Logs:')}            badgr logs ${dep.deployment_id}`);
+  console.log();
+}

package/src/commands/restart.js

@@ -0,0 +1,74 @@
+import { requireApiKey } from '../config.js';
+import { findDeployment, removeDeployment, addDeployment, addReceipt, generateReceiptId } from '../store.js';
+import { restartDeployment } from '../api.js';
+
+/**
+ * badgr restart <deployment-id|name>
+ *
+ * Tears down the current pod and relaunches an endpoint with the same
+ * config (GPU, model, price/cost/runtime caps, endpoint API key). Returns
+ * a *new* deployment_id and endpoint_url — the old pod's IP is gone.
+ */
+export async function restartCommand(config, args, chalk) {
+  const idOrName = args.find(a => !a.startsWith('--'));
+
+  if (!idOrName) {
+    console.error(chalk.red('Usage: badgr restart <deployment-id|name>'));
+    return;
+  }
+
+  requireApiKey(config);
+
+  const localDep     = findDeployment(idOrName);
+  const deploymentId = localDep?.id ?? idOrName;
+
+  process.stdout.write(chalk.dim(`  Restarting ${deploymentId}...`));
+
+  let dep;
+  try {
+    dep = await restartDeployment(config, deploymentId);
+  } catch (err) {
+    process.stdout.write('\n');
+    console.error(chalk.red(`\n  ✗ Could not restart deployment: ${err.message}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  process.stdout.write('\n');
+
+  removeDeployment(idOrName);
+  addDeployment({
+    id:          dep.deployment_id,
+    name:        dep.name,
+    type:        dep.workload_type,
+    model:       dep.model,
+    gpu:         dep.gpu_type,
+    count:       dep.gpu_count,
+    status:      dep.status,
+    endpointUrl: dep.endpoint_url || dep.openai_base_url,
+    receiptId:   dep.receipt_id,
+    createdAt:   new Date().toISOString(),
+    costPerHour: dep.cost_per_hour || 0,
+    providerRoute: dep.provider ?? null,
+    tier:          dep.tier ?? null,
+  });
+
+  const rcptId = dep.receipt_id || generateReceiptId();
+  addReceipt({
+    receiptId:    rcptId,
+    action:       'badgr restart',
+    deploymentId: dep.deployment_id,
+    gpu:          dep.gpu_type,
+    status:       dep.status,
+    createdAt:    new Date().toISOString(),
+  });
+
+  const endpointUrl = dep.endpoint_url || dep.openai_base_url;
+  console.log(chalk.green('\n  ✓ Restarted\n'));
+  console.log(`  ${chalk.bold('New deployment:')} ${chalk.cyan(dep.deployment_id)}`);
+  if (endpointUrl) console.log(`  ${chalk.bold('New base URL:')}   ${chalk.cyan(endpointUrl)}`);
+  console.log(chalk.dim('  Old endpoint URL is gone — update any client pointed at it.'));
+  console.log(chalk.dim('  Your endpoint API key is unchanged — no need to re-issue it.'));
+  console.log(`  ${chalk.bold('Status:')}         badgr status ${dep.deployment_id}`);
+  console.log();
+}

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/serve.js

@@ -32,6 +32,7 @@ export function parseServeArgs(args) {
     if (args[i] === '--name')       { flags.name = args[++i]; i++; continue; }
     if (args[i] === '--no-wait')               { flags.noWait = true; i++; continue; }
     if (args[i] === '--max-cost')              { flags.maxCost = parseFloat(args[++i]); i++; continue; }
+    if (args[i] === '--idle-timeout')          { flags.idleTimeout = parseInt(args[++i], 10); i++; continue; }
     if (args[i] === '--health-path')           { flags.healthPath = args[++i]; i++; continue; }
     if (args[i] === '--check-nodes')           { flags.checkNodes = args[++i]; i++; continue; }
     // All three aliases map to noMarketplaceFallback
@@ -208,7 +209,7 @@ async function validateComfyNodes(baseUrl, nodeList, chalk) {
 // Known badgr serve flags — used to detect broken shell line continuation.
 const _KNOWN_SERVE_FLAGS = new Set([
   '--gpu', '--image', '--task', '--count', '--region', '--tier', '--max-price',
-  '--name', '--no-wait', '--max-cost', '--health-path', '--check-nodes',
+  '--name', '--no-wait', '--max-cost', '--idle-timeout', '--health-path', '--check-nodes',
   '--no-fallback', '--strict-capacity', '--no-expanded-search', '--env',
   '--persistent', '--yes', '-y', '--runtime', '--hf-repo', '--hf-file',
 ]);
@@ -543,6 +544,7 @@ export async function serveCommand(config, args, chalk) {
       tier: tierOverride || effectiveTier,
       ...(Object.keys(effectiveEnv).length > 0 ? { env: effectiveEnv } : {}),
       ...(flags.maxCost ? { max_cost_usd: flags.maxCost } : {}),
+      ...(flags.idleTimeout ? { idle_timeout_minutes: flags.idleTimeout } : {}),
       ...(flags.healthPath ? { health_path: flags.healthPath } : {}),
     };
   }
@@ -746,22 +748,34 @@ export async function serveCommand(config, args, chalk) {
   else if (dep.model || effectiveModel) console.log(`  ${chalk.bold('Model:')}        ${dep.model || effectiveModel}`);
   if (customImage)        console.log(`  ${chalk.bold('Image:')}        ${customImage}`);
   if (flags.maxCost) console.log(`  ${chalk.bold('Max cost:')}     $${flags.maxCost.toFixed(2)}`);
+  if (flags.idleTimeout) console.log(`  ${chalk.bold('Idle timeout:')} ${flags.idleTimeout}m (auto-stops if idle — see Heartbeat below)`);
   console.log(`  ${chalk.bold('Logs:')}         badgr logs ${dep.deployment_id}`);
+  console.log(`  ${chalk.bold('Restart:')}      badgr restart ${dep.deployment_id}`);
   console.log(`  ${chalk.bold('Stop billing:')} ${chalk.cyan(`badgr down ${dep.deployment_id}`)}`);
   console.log(`  ${chalk.bold('Receipt:')}      badgr receipts ${rcptId}`);
   console.log();
   console.log(chalk.dim('  Billing continues until you run: ') + chalk.cyan(`badgr down ${dep.deployment_id}`));
 
   if (endpointReady && !customImage) {
-    const keySnip = config.apiKey?.slice(0, 4) || 'sk-...';
+    // dep.endpoint_api_key is a per-endpoint key generated for this deployment
+    // (vLLM model serves only) — shown exactly once, here. Falls back to the
+    // account-wide key (truncated) for serves that don't get one yet
+    // (custom images, managed transcribe/image tasks).
+    const hasEndpointKey = Boolean(dep.endpoint_api_key);
+    const authKey = hasEndpointKey ? dep.endpoint_api_key : `${config.apiKey?.slice(0, 4) || 'sk-...'}...`;
     const sdkModel = isLlamaCpp ? 'default' : (dep.model || effectiveModel);
+
+    if (hasEndpointKey) {
+      console.log(`  ${chalk.bold('API key:')}      ${chalk.yellow(dep.endpoint_api_key)}`);
+      console.log(chalk.dim('    Shown once — copy it now. This key is scoped to this endpoint only.'));
+    }
     console.log(`  ${chalk.bold('Test with curl:')}`);
     console.log(chalk.dim(`    curl ${endpointUrl}/chat/completions \\`));
-    console.log(chalk.dim(`      -H "Authorization: Bearer ${keySnip}..." -H "Content-Type: application/json" \\`));
+    console.log(chalk.dim(`      -H "Authorization: Bearer ${authKey}" -H "Content-Type: application/json" \\`));
     console.log(chalk.dim(`      -d '{"model":"${sdkModel}","messages":[{"role":"user","content":"Hello"}]}'`));
     console.log(`  ${chalk.bold('Use with OpenAI SDK:')}`);
     console.log(chalk.dim(`    from openai import OpenAI`));
-    console.log(chalk.dim(`    client = OpenAI(base_url="${endpointUrl}", api_key="${keySnip}...")`));
+    console.log(chalk.dim(`    client = OpenAI(base_url="${endpointUrl}", api_key="${authKey}")`));
     if (flags.task === 'transcribe') {
       console.log(chalk.dim(`    with open("audio.mp3", "rb") as f:`));
       console.log(chalk.dim(`        t = client.audio.transcriptions.create(model="${sdkModel}", file=f, response_format="text")`));
@@ -774,5 +788,13 @@ export async function serveCommand(config, args, chalk) {
       console.log(chalk.dim(`    resp = client.chat.completions.create(model="${sdkModel}", messages=[{"role": "user", "content": "Hello"}])`));
     }
     console.log();
+    if (flags.idleTimeout) {
+      console.log(`  ${chalk.bold('Heartbeat (required for --idle-timeout):')}`);
+      console.log(chalk.dim(`    badgr heartbeat ${dep.deployment_id}`));
+      console.log(chalk.dim('    Badgr does not proxy your inference traffic, so call this on each real'));
+      console.log(chalk.dim(`    request (or wire it into your client) — otherwise this endpoint auto-stops`));
+      console.log(chalk.dim(`    after ${flags.idleTimeout}m even if it's still reachable.`));
+      console.log();
+    }
   }
 }

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/);
+  });
+});