@thermai/flightdeck-cli 0.1.0-pilot.1

package/dist/index.js

@@ -0,0 +1,1176 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { readFileSync as readFileSync4 } from "node:fs";
+
+// src/submit-core.ts
+import { existsSync as existsSync2, mkdtempSync, readFileSync as readFileSync2, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join2, resolve } from "node:path";
+import { create as tarCreate } from "tar";
+
+// src/client.ts
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var DEFAULT_API_URL = "https://api.flightdeck.thermai.uk";
+var CONFIG_PATH = join(homedir(), ".flightdeck", "config.json");
+function normalizeApiUrl(value) {
+  const url = new URL(value);
+  const localHost = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]";
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && localHost)) {
+    throw new Error("FlightDeck API URLs must use HTTPS (HTTP is allowed only for localhost)");
+  }
+  if (url.username || url.password || url.search || url.hash) {
+    throw new Error("FlightDeck API URL must not contain credentials, a query, or a fragment");
+  }
+  url.pathname = url.pathname.replace(/\/$/, "");
+  return url.toString().replace(/\/$/, "");
+}
+function validConfig(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  if (typeof candidate.api_url !== "string" || typeof candidate.api_key !== "string") return false;
+  if (candidate.credential_id !== void 0 && typeof candidate.credential_id !== "string") return false;
+  try {
+    normalizeApiUrl(candidate.api_url);
+    return candidate.api_key.length > 0;
+  } catch {
+    return false;
+  }
+}
+function readConfig(path = CONFIG_PATH) {
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return validConfig(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function loadConfig() {
+  const config = readConfig();
+  if (!config) {
+    console.error(
+      `No valid login found at ${CONFIG_PATH}.
+Run: flightdeck login`
+    );
+    process.exit(1);
+  }
+  const stat = statSync(CONFIG_PATH);
+  if ((stat.mode & 63) !== 0) {
+    console.error(`Warning: ${CONFIG_PATH} is readable by other users; run chmod 600 ${CONFIG_PATH}`);
+  }
+  return config;
+}
+function saveConfig(config, path = CONFIG_PATH) {
+  if (!validConfig(config)) throw new Error("invalid FlightDeck configuration");
+  const directory = dirname(path);
+  mkdirSync(directory, { recursive: true, mode: 448 });
+  chmodSync(directory, 448);
+  const temporaryPath = `${path}.tmp-${process.pid}`;
+  try {
+    writeFileSync(temporaryPath, `${JSON.stringify(config, null, 2)}
+`, {
+      encoding: "utf8",
+      mode: 384,
+      flag: "wx"
+    });
+    chmodSync(temporaryPath, 384);
+    renameSync(temporaryPath, path);
+    chmodSync(path, 384);
+  } finally {
+    if (existsSync(temporaryPath)) unlinkSync(temporaryPath);
+  }
+}
+function deleteConfig(path = CONFIG_PATH) {
+  if (!existsSync(path)) return false;
+  unlinkSync(path);
+  return true;
+}
+function requestBody(body, headers) {
+  if (body instanceof FormData) return body;
+  if (!body) return void 0;
+  headers["Content-Type"] = "application/json";
+  return JSON.stringify(body);
+}
+function endpoint(apiUrl, path) {
+  return `${normalizeApiUrl(apiUrl)}/api/v1${path}`;
+}
+async function publicApiRequest(apiUrl, method, path, body) {
+  const headers = {};
+  return fetch(endpoint(apiUrl, path), {
+    method,
+    headers,
+    body: requestBody(body, headers)
+  });
+}
+async function apiRequest(method, path, body) {
+  const config = loadConfig();
+  const headers = {
+    Authorization: `Bearer ${config.api_key}`
+  };
+  return fetch(endpoint(config.api_url, path), {
+    method,
+    headers,
+    body: requestBody(body, headers)
+  });
+}
+
+// ../backend/contracts/environment.js
+var MAX_CUSTOMER_ENV_ENTRIES = 64;
+var MAX_RUNTIME_ENV_ENTRIES = 72;
+var MAX_ENV_KEY_CHARACTERS = 128;
+var MAX_ENV_VALUE_UTF8_BYTES = 4096;
+var MAX_CUSTOMER_ENV_UTF8_BYTES = 16 * 1024;
+var MAX_RUNTIME_ENV_UTF8_BYTES = 24 * 1024;
+var RESERVED_ENVIRONMENT_VARIABLES = Object.freeze([
+  "BUNDLE_URL",
+  "ENTRYPOINT_CMD",
+  "REQUIREMENTS_FILE",
+  "OUTPUTS_DIR",
+  "FLIGHT_ID",
+  "FLIGHTDECK_INGEST_URL",
+  "INGEST_TOKEN",
+  "NODE_ID",
+  "JOB_ID",
+  "ATTEMPT_SEQ"
+]);
+var RESERVED = new Set(RESERVED_ENVIRONMENT_VARIABLES);
+var ENVIRONMENT_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+var EnvironmentContractError = class extends Error {
+  constructor(issues) {
+    super(issues.join("; "));
+    this.name = "EnvironmentContractError";
+    this.issues = issues;
+  }
+};
+function utf8Bytes(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+function environmentContractIssues(value, mode = "customer") {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return ["environment must be a string record"];
+  }
+  const entries = Object.entries(value);
+  const runtime = mode === "runtime";
+  const maximumEntries = runtime ? MAX_RUNTIME_ENV_ENTRIES : MAX_CUSTOMER_ENV_ENTRIES;
+  const maximumBytes = runtime ? MAX_RUNTIME_ENV_UTF8_BYTES : MAX_CUSTOMER_ENV_UTF8_BYTES;
+  const issues = [];
+  let aggregateBytes = 0;
+  if (entries.length > maximumEntries) {
+    issues.push(`environment has more than ${maximumEntries} entries`);
+  }
+  for (const [name, rawValue] of entries) {
+    if (typeof rawValue !== "string") {
+      issues.push(`${name || "<empty>"} must have a string value`);
+      continue;
+    }
+    if (!ENVIRONMENT_NAME.test(name)) {
+      issues.push(`${name || "<empty>"} is an invalid environment variable name`);
+    }
+    if (name.length > MAX_ENV_KEY_CHARACTERS) {
+      issues.push(`${name} exceeds ${MAX_ENV_KEY_CHARACTERS} characters`);
+    }
+    if (!runtime && RESERVED.has(name)) {
+      issues.push(`${name} is reserved by Flightdeck`);
+    }
+    const valueBytes = utf8Bytes(rawValue);
+    if (valueBytes > MAX_ENV_VALUE_UTF8_BYTES) {
+      issues.push(`${name} exceeds ${MAX_ENV_VALUE_UTF8_BYTES} UTF-8 bytes`);
+    }
+    aggregateBytes += utf8Bytes(name) + 1 + valueBytes + 1;
+  }
+  if (aggregateBytes > maximumBytes) {
+    issues.push(`environment exceeds ${maximumBytes} aggregate UTF-8 bytes`);
+  }
+  return issues;
+}
+function assertEnvironmentContract(value, mode = "customer") {
+  const issues = environmentContractIssues(value, mode);
+  if (issues.length > 0) throw new EnvironmentContractError(issues);
+}
+
+// src/submit-core.ts
+var SubmitError = class extends Error {
+  constructor(status2, body) {
+    super(`Submit failed (${status2})`);
+    this.status = status2;
+    this.body = body;
+    this.name = "SubmitError";
+  }
+  status;
+  body;
+};
+function parseEnvironmentArguments(envArgs) {
+  const result = {};
+  for (const arg of envArgs ?? []) {
+    const equals = arg.indexOf("=");
+    if (equals < 1) throw new Error(`invalid env var format: ${arg} (expected KEY=VALUE)`);
+    result[arg.slice(0, equals)] = arg.slice(equals + 1);
+  }
+  assertEnvironmentContract(result, "customer");
+  return result;
+}
+async function createBundle(filePaths) {
+  for (const filePath of filePaths) {
+    if (!existsSync2(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+  }
+  const tempDir = mkdtempSync(join2(tmpdir(), "flightdeck-"));
+  const bundlePath = join2(tempDir, "bundle.tar.gz");
+  try {
+    await tarCreate({ gzip: true, file: bundlePath, cwd: resolve(".") }, filePaths);
+    return readFileSync2(bundlePath);
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+async function submitFlight(plan, bundle) {
+  assertEnvironmentContract(plan.env_vars ?? {}, "customer");
+  const formData = new FormData();
+  formData.append("plan", JSON.stringify(plan));
+  formData.append(
+    "bundle",
+    new Blob([bundle], { type: "application/gzip" }),
+    "bundle.tar.gz"
+  );
+  const response = await apiRequest("POST", "/jobs/submit", formData);
+  const body = await response.json();
+  if (!response.ok) {
+    throw new SubmitError(response.status, body);
+  }
+  return body;
+}
+
+// src/commands/submit.ts
+function parseDuration(input) {
+  const match = input.match(/^(\d+)(h|m|s)?$/);
+  if (!match) {
+    console.error(`Invalid duration: ${input} (use e.g. 1h, 30m, 3600s)`);
+    process.exit(1);
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2] ?? "s";
+  switch (unit) {
+    case "h":
+      return value * 3600;
+    case "m":
+      return value * 60;
+    default:
+      return value;
+  }
+}
+async function submit(entrypoint, options) {
+  console.log(`Packaging files...`);
+  let bundle;
+  try {
+    bundle = await createBundle(options.files ?? ["."]);
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+  console.log(`Bundle: ${(bundle.length / 1024 / 1024).toFixed(1)} MB`);
+  const plan = {
+    name: options.name,
+    entrypoint,
+    requirements_file: options.requirements,
+    gpu_type: options.gpu,
+    gpu_count: parseInt(options.gpuCount, 10),
+    max_duration_s: parseDuration(options.time),
+    env_vars: parseEnvironmentArguments(options.env),
+    ...options.baseImage ? { base_image: options.baseImage } : {},
+    ...options.provider ? { requested_provider: options.provider } : {}
+  };
+  console.log(`Submitting to FlightDeck...`);
+  try {
+    const body = await submitFlight(plan, bundle);
+    console.log(`
+Flight submitted successfully!`);
+    console.log(`  Flight ID:      ${body.flight_id}`);
+    console.log(`  Status:         ${body.status}`);
+    console.log(`  Est. cost:      ${body.estimated_cost_pence}p`);
+    console.log(`  Queue position: ${body.position_in_queue}`);
+    console.log(`
+Track with: flightdeck status ${body.flight_id}`);
+  } catch (err) {
+    if (err instanceof SubmitError) {
+      console.error(`Submit failed (${err.status}):`, JSON.stringify(err.body, null, 2));
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+
+// src/commands/sbatch.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname2, isAbsolute, normalize, relative, resolve as resolve2 } from "node:path";
+
+// src/sbatch.ts
+var SHORT_OPTS = {
+  "-J": "--job-name",
+  "-a": "--array",
+  "-t": "--time",
+  "-G": "--gpus",
+  "-o": "--output",
+  "-e": "--error",
+  "-D": "--chdir",
+  "-n": "--ntasks",
+  "-N": "--nodes",
+  "-p": "--partition",
+  "-c": "--cpus-per-task"
+};
+var VALUE_OPTIONS = /* @__PURE__ */ new Set([
+  "--job-name",
+  "--array",
+  "--time",
+  "--gres",
+  "--gpus",
+  "--gpus-per-node",
+  "--gpus-per-task",
+  "--output",
+  "--error",
+  "--chdir",
+  "--ntasks",
+  "--nodes",
+  "--cpus-per-task",
+  "--export",
+  "--partition",
+  "--account",
+  "--qos",
+  "--constraint",
+  "--dependency",
+  "--mem",
+  "--mem-per-cpu",
+  "--mem-per-gpu",
+  "--mail-type",
+  "--mail-user"
+]);
+var MAX_ARRAY_TASKS = 1e3;
+var MAX_GPU_COUNT = 64;
+function unquote(value) {
+  const trimmed = value.trim();
+  if (trimmed.length >= 2 && (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function tokenizeDirective(rest) {
+  const tokens = [];
+  let token = "";
+  let quote = null;
+  let escaped = false;
+  let started = false;
+  for (const char of rest) {
+    if (escaped) {
+      token += char;
+      escaped = false;
+      started = true;
+      continue;
+    }
+    if (char === "\\" && quote !== "'") {
+      escaped = true;
+      started = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) quote = null;
+      else token += char;
+      started = true;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      started = true;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (started) {
+        tokens.push(token);
+        token = "";
+        started = false;
+      }
+      continue;
+    }
+    token += char;
+    started = true;
+  }
+  if (quote) throw new Error("unterminated quote in SBATCH directive");
+  if (escaped) token += "\\";
+  if (started) tokens.push(token);
+  return tokens;
+}
+function splitOptions(rest) {
+  const tokens = tokenizeDirective(rest);
+  const options = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    let rawKey = token;
+    let value;
+    if (token.startsWith("--")) {
+      const eqIndex = token.indexOf("=");
+      if (eqIndex !== -1) {
+        rawKey = token.slice(0, eqIndex);
+        value = token.slice(eqIndex + 1);
+      }
+    } else if (token.startsWith("-") && token.length >= 2) {
+      rawKey = token.slice(0, 2);
+      const remainder = token.slice(2).replace(/^=/, "");
+      if (remainder) value = remainder;
+    }
+    const key = SHORT_OPTS[rawKey] ?? rawKey;
+    if (value === void 0 && VALUE_OPTIONS.has(key)) {
+      const next = tokens[index + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        value = next;
+        index += 1;
+      }
+    }
+    options.push({ key, value: value === void 0 ? void 0 : unquote(value) });
+  }
+  return options;
+}
+function positiveInteger(value, option) {
+  if (value === void 0) throw new Error(`${option} requires a value`);
+  if (!/^\d+$/.test(value) || !Number.isSafeInteger(Number(value)) || Number(value) < 1) {
+    throw new Error(`${option} must be a positive integer`);
+  }
+  return Number(value);
+}
+function parseExport(value, result) {
+  if (value === void 0) throw new Error("--export requires a value");
+  for (const item of value.split(",")) {
+    if (item === "ALL" || item === "NONE" || item === "NIL") continue;
+    const eqIndex = item.indexOf("=");
+    if (eqIndex < 1) {
+      result.warnings.push(
+        `--export=${item} requests a client-shell variable; pass it explicitly with --env ${item}=VALUE`
+      );
+      continue;
+    }
+    const name = item.slice(0, eqIndex);
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+      throw new Error(`invalid environment variable name in --export: "${name}"`);
+    }
+    result.exportedEnv[name] = item.slice(eqIndex + 1);
+  }
+}
+function parseSlurmTime(value) {
+  let days = 0;
+  let rest = value.trim();
+  if (rest === "") return null;
+  const dashIndex = rest.indexOf("-");
+  const hasDays = dashIndex !== -1;
+  if (hasDays) {
+    if (rest.indexOf("-", dashIndex + 1) !== -1) return null;
+    days = Number(rest.slice(0, dashIndex));
+    rest = rest.slice(dashIndex + 1);
+    if (!Number.isInteger(days) || days < 0 || rest === "") return null;
+  }
+  const rawParts = rest.split(":");
+  if (rawParts.length < 1 || rawParts.length > 3) return null;
+  if (rawParts.some((part) => !/^\d+$/.test(part))) return null;
+  const parts = rawParts.map((part) => Number(part));
+  if (parts.some((part) => !Number.isInteger(part) || part < 0)) return null;
+  let hours = 0;
+  let minutes = 0;
+  let seconds = 0;
+  if (hasDays) {
+    [hours = 0, minutes = 0, seconds = 0] = parts;
+    if (hours > 23 || minutes > 59 || seconds > 59) return null;
+  } else if (parts.length === 1) {
+    [minutes] = parts;
+  } else if (parts.length === 2) {
+    [minutes, seconds] = parts;
+    if (seconds > 59) return null;
+  } else if (parts.length === 3) {
+    [hours, minutes, seconds] = parts;
+    if (minutes > 59 || seconds > 59) return null;
+  } else {
+    return null;
+  }
+  return days * 86400 + hours * 3600 + minutes * 60 + seconds;
+}
+function parseArraySpec(spec) {
+  const raw = spec.trim();
+  let body = raw;
+  let concurrency;
+  const percentIndex = body.indexOf("%");
+  if (percentIndex !== -1) {
+    concurrency = Number(body.slice(percentIndex + 1));
+    body = body.slice(0, percentIndex);
+    if (!Number.isInteger(concurrency) || concurrency <= 0) {
+      throw new Error(`invalid --array concurrency limit in "${raw}"`);
+    }
+  }
+  const tasks = /* @__PURE__ */ new Set();
+  for (const element of body.split(",")) {
+    const part = element.trim();
+    const range = part.match(/^(\d+)-(\d+)(?::(\d+))?$/);
+    if (range) {
+      const start = Number(range[1]);
+      const end = Number(range[2]);
+      const step = range[3] ? Number(range[3]) : 1;
+      if (![start, end, step].every(Number.isSafeInteger)) {
+        throw new Error(`--array values must be safe integers in "${raw}"`);
+      }
+      if (step <= 0) throw new Error(`invalid --array step in "${raw}"`);
+      if (end < start) throw new Error(`invalid --array range "${part}" (end < start)`);
+      for (let id = start; id <= end; id += step) {
+        tasks.add(id);
+        if (tasks.size > MAX_ARRAY_TASKS) {
+          throw new Error(`--array expands to more than ${MAX_ARRAY_TASKS} tasks`);
+        }
+      }
+    } else if (/^\d+$/.test(part)) {
+      const id = Number(part);
+      if (!Number.isSafeInteger(id)) throw new Error(`--array values must be safe integers in "${raw}"`);
+      tasks.add(id);
+      if (tasks.size > MAX_ARRAY_TASKS) {
+        throw new Error(`--array expands to more than ${MAX_ARRAY_TASKS} tasks`);
+      }
+    } else {
+      throw new Error(`invalid --array element "${part}" in "${raw}"`);
+    }
+  }
+  return { tasks: [...tasks].sort((a, b) => a - b), concurrency, raw };
+}
+function parseGpuRequest(value, fromGres) {
+  let tokens = value.split(":");
+  if (fromGres) {
+    if (tokens[0] !== "gpu") {
+      return { warning: `--gres=${value} is not a GPU request; ignored` };
+    }
+    tokens = tokens.slice(1);
+  }
+  if (tokens.length === 0 || tokens[0] === "") {
+    return { gpuCount: 1 };
+  }
+  if (tokens.length === 1) {
+    const onlyToken = tokens[0];
+    if (/^\d+$/.test(onlyToken)) {
+      const count2 = Number(onlyToken);
+      if (!Number.isSafeInteger(count2) || count2 < 1 || count2 > MAX_GPU_COUNT) {
+        throw new Error(`GPU count must be between 1 and ${MAX_GPU_COUNT} in "${value}"`);
+      }
+      return { gpuCount: count2 };
+    }
+    return { gpuType: onlyToken, gpuCount: 1 };
+  }
+  const [type, count] = tokens;
+  if (!/^\d+$/.test(count) || !Number.isSafeInteger(Number(count)) || Number(count) < 1 || Number(count) > MAX_GPU_COUNT) {
+    throw new Error(`GPU count must be between 1 and ${MAX_GPU_COUNT} in "${value}"`);
+  }
+  return { gpuType: type, gpuCount: Number(count) };
+}
+function parseSbatchScript(text) {
+  const result = { warnings: [], exportedEnv: {} };
+  const ignored = /* @__PURE__ */ new Set();
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.trim();
+    if (line === "") continue;
+    if (!line.startsWith("#")) break;
+    if (!/^#SBATCH\b/.test(line)) continue;
+    const rest = line.replace(/^#SBATCH\s*/, "").trim();
+    if (rest === "") continue;
+    for (const { key, value } of splitOptions(rest)) switch (key) {
+      case "--job-name":
+        if (!value) throw new Error("--job-name requires a value");
+        result.jobName = value;
+        break;
+      case "--array":
+        if (!value) throw new Error("--array requires a value");
+        result.array = parseArraySpec(value);
+        break;
+      case "--time":
+        if (!value) throw new Error("--time requires a value");
+        {
+          const seconds = parseSlurmTime(value);
+          if (seconds === null || seconds < 1) throw new Error(`invalid --time value "${value}"`);
+          result.maxDurationS = seconds;
+        }
+        break;
+      case "--gres":
+        if (!value) throw new Error("--gres requires a value");
+        {
+          const gpu = parseGpuRequest(value, true);
+          if (gpu.warning) result.warnings.push(gpu.warning);
+          if (gpu.gpuCount != null) result.gpuCount = gpu.gpuCount;
+          if (gpu.gpuType) result.gpuType = gpu.gpuType;
+        }
+        break;
+      case "--gpus":
+      case "--gpus-per-node":
+      case "--gpus-per-task":
+        if (!value) throw new Error(`${key} requires a value`);
+        {
+          const gpu = parseGpuRequest(value, false);
+          if (gpu.warning) result.warnings.push(gpu.warning);
+          if (gpu.gpuCount != null) result.gpuCount = gpu.gpuCount;
+          if (gpu.gpuType) result.gpuType = gpu.gpuType;
+        }
+        break;
+      case "--output":
+        if (!value) throw new Error("--output requires a value");
+        result.outputPath = value;
+        break;
+      case "--error":
+        if (!value) throw new Error("--error requires a value");
+        result.errorPath = value;
+        break;
+      case "--chdir":
+        if (!value) throw new Error("--chdir requires a value");
+        result.workingDirectory = value;
+        break;
+      case "--nodes":
+        result.nodes = positiveInteger(value, "--nodes");
+        if (result.nodes !== 1) {
+          throw new Error("multi-node jobs are not supported; --nodes must be 1");
+        }
+        break;
+      case "--ntasks":
+        result.tasks = positiveInteger(value, "--ntasks");
+        if (result.tasks !== 1) {
+          result.warnings.push(
+            `--ntasks=${result.tasks} records the Slurm environment only; Flightdeck does not provide srun or launch multiple processes`
+          );
+        }
+        break;
+      case "--cpus-per-task":
+        result.cpusPerTask = positiveInteger(value, "--cpus-per-task");
+        result.warnings.push(
+          "--cpus-per-task is exposed as SLURM_CPUS_PER_TASK but is not a provider resource guarantee"
+        );
+        break;
+      case "--export":
+        parseExport(value, result);
+        break;
+      default:
+        ignored.add(key);
+    }
+  }
+  if (ignored.size > 0) {
+    result.warnings.push(`ignored unsupported directives: ${[...ignored].sort().join(", ")}`);
+  }
+  assertEnvironmentContract(result.exportedEnv, "customer");
+  return result;
+}
+
+// src/commands/sbatch.ts
+var MAX_DURATION_S = 86400;
+var WORKSPACE_ROOT = "/workspace";
+var OUTPUT_ROOT = "/outputs";
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function bundlePathsForScript(filePaths, relativeScript) {
+  if (filePaths == null) return ["."];
+  if (filePaths.some((filePath) => resolve2(filePath) === resolve2(relativeScript))) {
+    return filePaths;
+  }
+  return [...filePaths, relativeScript];
+}
+function parseEnvVars(envArgs) {
+  return parseEnvironmentArguments(envArgs);
+}
+function expandSlurmFilename(pattern, context) {
+  const expanded = pattern.replace(/%([%AajJx])/g, (_match, symbol) => {
+    switch (symbol) {
+      case "%":
+        return "%";
+      case "A":
+        return context.jobId;
+      case "a":
+        return context.taskId === null ? "4294967294" : String(context.taskId);
+      case "j":
+      case "J":
+        return context.jobId;
+      case "x":
+        return context.jobName;
+      default:
+        return _match;
+    }
+  });
+  const unsupported = expanded.match(/%[A-Za-z]/)?.[0];
+  if (unsupported) throw new Error(`unsupported Slurm filename replacement: ${unsupported}`);
+  return expanded;
+}
+function safeRelativePath(value, option) {
+  if (isAbsolute(value)) throw new Error(`${option} must be relative to the submitted workspace`);
+  const path = normalize(value);
+  if (path === ".." || path.startsWith("../") || path === "." || path === "") {
+    throw new Error(`${option} must stay inside the submitted workspace`);
+  }
+  return path;
+}
+function outputTarget(pattern, context) {
+  const expanded = safeRelativePath(expandSlurmFilename(pattern, context), "--output/--error");
+  return `${OUTPUT_ROOT}/${expanded}`;
+}
+function buildEntrypoint(args) {
+  const script = safeRelativePath(args.relativeScript, "script path");
+  const workingDirectory = args.workingDirectory ? safeRelativePath(args.workingDirectory, "--chdir") : null;
+  const context = { jobId: args.jobId, jobName: args.jobName, taskId: args.taskId };
+  const stdout = outputTarget(args.outputPath ?? "slurm-%j.out", context);
+  const stderr = args.errorPath ? outputTarget(args.errorPath, context) : stdout;
+  const outputDirectories = [.../* @__PURE__ */ new Set([dirname2(stdout), dirname2(stderr)])];
+  const command = `bash -- ${shellQuote(`${WORKSPACE_ROOT}/${script}`)}`;
+  const redirected = stdout === stderr ? `${command} > >(tee -- ${shellQuote(stdout)}) 2>&1` : `${command} > >(tee -- ${shellQuote(stdout)}) 2> >(tee -- ${shellQuote(stderr)} >&2)`;
+  const cd = workingDirectory ? `cd -- ${shellQuote(`${WORKSPACE_ROOT}/${workingDirectory}`)} && ` : `cd -- ${shellQuote(WORKSPACE_ROOT)} && `;
+  return `mkdir -p -- ${outputDirectories.map(shellQuote).join(" ")} && ${cd}{ ${redirected}; __flightdeck_status=$?; wait; exit "$__flightdeck_status"; }`;
+}
+function slurmEnvironment(args) {
+  const tasks = args.directives.array?.tasks ?? [];
+  const gpuCount = args.directives.gpuCount ?? 1;
+  const env = {
+    ...args.directives.exportedEnv,
+    ...args.extraEnv,
+    SLURM_CLUSTER_NAME: "flightdeck",
+    SLURM_JOB_NAME: args.jobName,
+    SLURM_JOB_ID: args.jobId,
+    SLURM_JOBID: args.jobId,
+    SLURM_SUBMIT_DIR: WORKSPACE_ROOT,
+    SLURM_NTASKS: String(args.directives.tasks ?? 1),
+    SLURM_NPROCS: String(args.directives.tasks ?? 1),
+    SLURM_NNODES: "1",
+    SLURM_JOB_NUM_NODES: "1",
+    SLURM_GPUS: String(gpuCount),
+    SLURM_GPUS_ON_NODE: String(gpuCount),
+    SLURM_JOB_GPUS: Array.from({ length: gpuCount }, (_, index) => index).join(",")
+  };
+  if (args.directives.cpusPerTask !== void 0) {
+    env.SLURM_CPUS_PER_TASK = String(args.directives.cpusPerTask);
+  }
+  if (args.taskId !== null) {
+    env.SLURM_ARRAY_JOB_ID = args.jobId;
+    env.SLURM_ARRAY_TASK_ID = String(args.taskId);
+    env.SLURM_ARRAY_TASK_COUNT = String(tasks.length);
+    env.SLURM_ARRAY_TASK_MIN = String(tasks[0]);
+    env.SLURM_ARRAY_TASK_MAX = String(tasks[tasks.length - 1]);
+  }
+  assertEnvironmentContract(env, "customer");
+  return env;
+}
+function buildSbatchPlans(args) {
+  const jobName = args.options.name ?? args.directives.jobName ?? "sbatch-job";
+  const taskIds = args.directives.array?.tasks ?? [null];
+  const extraEnv = parseEnvVars(args.options.env);
+  let maxDurationS = args.directives.maxDurationS;
+  if (maxDurationS !== void 0 && maxDurationS > MAX_DURATION_S) maxDurationS = MAX_DURATION_S;
+  return taskIds.map((taskId) => ({
+    taskId,
+    plan: {
+      name: taskId === null ? jobName : `${jobName}[${taskId}]`,
+      entrypoint: buildEntrypoint({
+        relativeScript: args.relativeScript,
+        workingDirectory: args.directives.workingDirectory,
+        outputPath: args.directives.outputPath,
+        errorPath: args.directives.errorPath,
+        jobId: args.jobId,
+        jobName,
+        taskId
+      }),
+      requirements_file: args.options.requirements,
+      gpu_type: args.directives.gpuType,
+      gpu_count: args.directives.gpuCount,
+      max_duration_s: maxDurationS,
+      env_vars: slurmEnvironment({
+        directives: args.directives,
+        taskId,
+        jobId: args.jobId,
+        jobName,
+        extraEnv
+      }),
+      base_image: args.options.baseImage,
+      requested_provider: args.options.provider
+    }
+  }));
+}
+async function sbatch(scriptPath, options) {
+  if (!existsSync3(scriptPath)) {
+    console.error(`Script not found: ${scriptPath}`);
+    process.exit(1);
+  }
+  const scriptText = readFileSync3(scriptPath, "utf-8");
+  let directives;
+  try {
+    directives = parseSbatchScript(scriptText);
+  } catch (err) {
+    console.error(`Invalid SBATCH directive: ${err.message}`);
+    process.exit(1);
+  }
+  const relativeScript = relative(resolve2("."), resolve2(scriptPath));
+  if (relativeScript === ".." || relativeScript.startsWith("../") || isAbsolute(relativeScript) || relativeScript === "") {
+    console.error(
+      `Script must be inside the current directory so it can be bundled.
+Run flightdeck from the directory containing "${scriptPath}".`
+    );
+    process.exit(1);
+  }
+  const jobName = options.name ?? directives.jobName ?? "sbatch-job";
+  let maxDurationS = directives.maxDurationS;
+  if (maxDurationS != null && maxDurationS > MAX_DURATION_S) {
+    directives.warnings.push(
+      `--time exceeds the 24h maximum; capping at ${MAX_DURATION_S}s`
+    );
+    maxDurationS = MAX_DURATION_S;
+  }
+  const jobId = `${Date.now()}${String(process.pid % 1e3).padStart(3, "0")}`;
+  let tasks;
+  try {
+    tasks = buildSbatchPlans({ directives, relativeScript, options, jobId });
+  } catch (err) {
+    console.error(`Invalid SBATCH submission: ${err.message}`);
+    process.exit(1);
+  }
+  console.log(`Parsed ${scriptPath}:`);
+  console.log(`  Job name:   ${jobName}`);
+  console.log(`  Entrypoint: ${tasks[0].plan.entrypoint}`);
+  console.log(`  GPU:        ${directives.gpuType ?? "any"} x${directives.gpuCount ?? 1}`);
+  console.log(`  Max time:   ${maxDurationS != null ? `${maxDurationS}s` : "platform default"}`);
+  console.log(`  Base image: ${options.baseImage ?? "platform default"}`);
+  if (directives.array) {
+    console.log(
+      `  Array:      ${directives.array.raw} \u2192 ${tasks.length} task(s)` + (directives.array.concurrency ? ` (note: %${directives.array.concurrency} concurrency limit is not enforced \u2014 all tasks queue at once)` : "")
+    );
+  }
+  for (const warning of directives.warnings) {
+    console.log(`  warning: ${warning}`);
+  }
+  if (options.dryRun) {
+    console.log(`
+Dry run \u2014 ${tasks.length} flight(s) would be submitted:`);
+    for (const task of tasks) {
+      console.log(`  - ${task.plan.name}`);
+    }
+    return { submitted: [], failures: 0 };
+  }
+  console.log(`
+Packaging files...`);
+  let bundle;
+  try {
+    bundle = await createBundle(bundlePathsForScript(options.files, relativeScript));
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+  console.log(`Bundle: ${(bundle.length / 1024 / 1024).toFixed(1)} MB`);
+  console.log(`Submitting ${tasks.length} flight(s)...
+`);
+  const submitted = [];
+  let failures = 0;
+  for (const task of tasks) {
+    try {
+      const result = await submitFlight(task.plan, bundle);
+      submitted.push({ flightId: result.flight_id, taskId: task.taskId, name: task.plan.name });
+      console.log(`  ${task.plan.name}: ${result.flight_id} (queue #${result.position_in_queue})`);
+    } catch (err) {
+      failures += 1;
+      if (err instanceof SubmitError) {
+        console.error(`  ${task.plan.name}: failed (${err.status}) ${JSON.stringify(err.body)}`);
+      } else {
+        console.error(`  ${task.plan.name}: ${err.message}`);
+      }
+    }
+  }
+  console.log(`
+${submitted.length} submitted, ${failures} failed.`);
+  if (submitted.length > 0) {
+    console.log(`Track with: flightdeck status <flight_id>`);
+  }
+  if (failures > 0) process.exit(1);
+  return { submitted, failures };
+}
+
+// src/commands/status.ts
+async function status(flightId) {
+  const response = await apiRequest("GET", `/flights/${flightId}`);
+  const body = await response.json();
+  if (!response.ok) {
+    console.error(`Failed (${response.status}):`, JSON.stringify(body, null, 2));
+    process.exit(1);
+  }
+  console.log(`Flight: ${body.flight_id}`);
+  console.log(`  Name:     ${body.name}`);
+  console.log(`  Status:   ${body.status}`);
+  console.log(`  Image:    ${body.image}`);
+  console.log(`  GPU:      ${body.gpu_type ?? "any"} x${body.gpu_count}`);
+  if (body.queued_at) console.log(`  Queued:   ${body.queued_at}`);
+  if (body.started_at) console.log(`  Started:  ${body.started_at}`);
+  if (body.completed_at) console.log(`  Finished: ${body.completed_at}`);
+  if (body.exit_code != null) console.log(`  Exit:     ${body.exit_code}`);
+  if (body.error_message) console.log(`  Error:    ${body.error_message}`);
+  if (body.cost_pence) console.log(`  Cost:     ${body.cost_pence}p`);
+}
+
+// src/commands/logs.ts
+async function logs(flightId, options) {
+  let cursor;
+  do {
+    const query = cursor ? `?cursor=${encodeURIComponent(cursor)}` : "";
+    const response = await apiRequest("GET", `/flights/${flightId}/logs${query}`);
+    const body = await response.json();
+    if (!response.ok) throw new Error(`Failed (${response.status}): ${JSON.stringify(body)}`);
+    for (const entry of body.logs) {
+      const target = entry.stream === "stderr" ? process.stderr : process.stdout;
+      target.write(entry.content);
+    }
+    cursor = body.next_cursor;
+    if (!options.follow || body.complete) break;
+    await new Promise((resolve4) => setTimeout(resolve4, 2e3));
+  } while (true);
+}
+
+// src/commands/cancel.ts
+async function cancel(flightId) {
+  const response = await apiRequest("DELETE", `/flights/${flightId}`);
+  const body = await response.json();
+  if (!response.ok) throw new Error(`Failed (${response.status}): ${JSON.stringify(body)}`);
+  console.log(`Cancelled ${flightId}`);
+}
+
+// src/commands/outputs.ts
+async function listOutputs(flightId) {
+  const response = await apiRequest("GET", `/flights/${flightId}/outputs`);
+  const body = await response.json();
+  if (!response.ok) throw new Error(`Failed (${response.status}): ${JSON.stringify(body)}`);
+  const outputs = body.outputs ?? [];
+  if (!outputs.length) console.log("No outputs available.");
+  for (const output of outputs) console.log(`${output.artifact_id}  ${output.size_bytes} bytes  ${output.filename}`);
+  return;
+}
+
+// src/commands/download.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import { basename, join as join3, resolve as resolve3 } from "node:path";
+async function download(flightId, options) {
+  const manifestResponse = await apiRequest("GET", `/flights/${flightId}/outputs`);
+  const manifest = await manifestResponse.json();
+  if (!manifestResponse.ok) throw new Error(`Failed (${manifestResponse.status}): ${JSON.stringify(manifest)}`);
+  const root = resolve3(options.outputDir);
+  await mkdir(root, { recursive: true });
+  for (const output of manifest.outputs ?? []) {
+    const response = await apiRequest("GET", `/flights/${flightId}/outputs/${output.artifact_id}`);
+    if (!response.ok) throw new Error(`Download failed for ${output.filename} (${response.status})`);
+    const target = join3(root, basename(output.filename));
+    await writeFile(target, Buffer.from(await response.arrayBuffer()), { flag: "wx" });
+    console.log(`Downloaded ${target}`);
+  }
+}
+
+// src/commands/slurm-test.ts
+import { mkdtempSync as mkdtempSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join4, relative as relative2 } from "node:path";
+var TERMINAL = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+var CONFORMANCE_SCRIPT = `#!/bin/bash
+#SBATCH --job-name=slurm-conformance
+#SBATCH --array=2,5
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=1
+#SBATCH --time=00:05:00
+#SBATCH --output=conformance/%A_%a.out
+#SBATCH --error=conformance/%A_%a.err
+#SBATCH --export=FLIGHTDECK_CONFORMANCE=enabled
+
+set -euo pipefail
+test "$FLIGHTDECK_CONFORMANCE" = "enabled"
+test "$SLURM_CLUSTER_NAME" = "flightdeck"
+test "$SLURM_JOB_NAME" = "slurm-conformance"
+test -n "$SLURM_JOB_ID"
+test "$SLURM_ARRAY_JOB_ID" = "$SLURM_JOB_ID"
+test "$SLURM_NNODES" = "1"
+test "$SLURM_NTASKS" = "1"
+test "$SLURM_CPUS_PER_TASK" = "1"
+printf 'task=%s job=%s
+' "$SLURM_ARRAY_TASK_ID" "$SLURM_JOB_ID"   > "$OUTPUTS_DIR/conformance-$SLURM_ARRAY_TASK_ID.txt"
+printf 'FLIGHTDECK_SLURM_CONFORMANCE task=%s
+' "$SLURM_ARRAY_TASK_ID"
+`;
+function positiveSeconds(value, option) {
+  if (!/^\d+$/.test(value) || Number(value) < 1) {
+    throw new Error(`${option} must be a positive number of seconds`);
+  }
+  return Number(value);
+}
+async function readFlight(flightId) {
+  const response = await apiRequest("GET", `/flights/${flightId}`);
+  const body = await response.json();
+  if (!response.ok) throw new Error(`status ${flightId} failed (${response.status}): ${JSON.stringify(body)}`);
+  return body;
+}
+async function verifyResults(flightId, taskId) {
+  const [logsResponse, outputsResponse] = await Promise.all([
+    apiRequest("GET", `/flights/${flightId}/logs`),
+    apiRequest("GET", `/flights/${flightId}/outputs`)
+  ]);
+  const logs2 = await logsResponse.json();
+  const outputs = await outputsResponse.json();
+  if (!logsResponse.ok) throw new Error(`logs ${flightId} failed (${logsResponse.status}): ${JSON.stringify(logs2)}`);
+  if (!outputsResponse.ok) throw new Error(`outputs ${flightId} failed (${outputsResponse.status}): ${JSON.stringify(outputs)}`);
+  const combinedLogs = (logs2.logs ?? []).map((entry) => entry.content).join("\n");
+  if (!combinedLogs.includes(`FLIGHTDECK_SLURM_CONFORMANCE task=${taskId}`)) {
+    throw new Error(`${flightId}: provider logs do not contain the task ${taskId} conformance marker`);
+  }
+  if (!(outputs.outputs ?? []).some((output) => output.size_bytes > 0)) {
+    throw new Error(`${flightId}: provider returned no non-empty output artifact`);
+  }
+}
+async function slurmTest(options) {
+  const timeoutMs = positiveSeconds(options.timeout, "--timeout") * 1e3;
+  const pollIntervalMs = positiveSeconds(options.pollInterval, "--poll-interval") * 1e3;
+  const tempDir = mkdtempSync2(join4(process.cwd(), ".flightdeck-slurm-test-"));
+  const scriptPath = join4(tempDir, "conformance.sbatch");
+  writeFileSync2(scriptPath, CONFORMANCE_SCRIPT, { encoding: "utf8", mode: 448 });
+  let submitted;
+  try {
+    const result = await sbatch(relative2(process.cwd(), scriptPath), {
+      files: [relative2(process.cwd(), tempDir)]
+    });
+    submitted = result.submitted;
+  } finally {
+    rmSync2(tempDir, { recursive: true, force: true });
+  }
+  if (submitted.length !== 2) throw new Error(`expected 2 conformance flights, submitted ${submitted.length}`);
+  const deadline = Date.now() + timeoutMs;
+  const pending = new Map(submitted.map((task) => [task.flightId, task]));
+  const finished = /* @__PURE__ */ new Map();
+  while (pending.size > 0 && Date.now() < deadline) {
+    for (const task of [...pending.values()]) {
+      const flight = await readFlight(task.flightId);
+      if (flight.status && TERMINAL.has(flight.status)) {
+        pending.delete(task.flightId);
+        finished.set(task.flightId, flight);
+        console.log(`  ${task.name}: ${flight.status} (${flight.provider ?? "provider pending"})`);
+      }
+    }
+    if (pending.size > 0) await new Promise((resolve4) => setTimeout(resolve4, pollIntervalMs));
+  }
+  if (pending.size > 0) {
+    throw new Error(`timed out waiting for: ${[...pending.keys()].join(", ")}`);
+  }
+  for (const task of submitted) {
+    const flight = finished.get(task.flightId);
+    if (flight.status !== "completed" || flight.exit_code !== 0) {
+      throw new Error(`${task.flightId} failed conformance: ${flight.error_message ?? `exit ${flight.exit_code}`}`);
+    }
+    await verifyResults(task.flightId, task.taskId);
+  }
+  console.log(`
+Slurm provider conformance passed for ${submitted.length} array tasks.`);
+}
+
+// src/commands/login.ts
+var SCOPES = ["jobs:read", "jobs:submit", "jobs:cancel", "account:read"];
+function sleep(milliseconds) {
+  return new Promise((resolve4) => setTimeout(resolve4, milliseconds));
+}
+async function errorMessage(response) {
+  try {
+    const body = await response.json();
+    return body.error ?? response.statusText;
+  } catch {
+    return response.statusText;
+  }
+}
+async function login(options) {
+  if (readConfig()) {
+    throw new Error("Already logged in. Run `flightdeck logout` before replacing this credential.");
+  }
+  const apiUrl = normalizeApiUrl(options.apiUrl ?? DEFAULT_API_URL);
+  const started = await publicApiRequest(apiUrl, "POST", "/auth/device/code", {
+    credential_name: options.name ?? "flightdeck-cli",
+    scopes: SCOPES
+  });
+  if (!started.ok) throw new Error(`Unable to start login: ${await errorMessage(started)}`);
+  const authorization = await started.json();
+  console.log(`Open this URL to approve the CLI:
+${authorization.verification_uri_complete}`);
+  console.log(`
+Verification code: ${authorization.user_code}`);
+  console.log("Waiting for approval\u2026");
+  const deadline = Date.now() + authorization.expires_in * 1e3;
+  let intervalSeconds = Math.max(1, authorization.interval);
+  while (Date.now() < deadline) {
+    await sleep(intervalSeconds * 1e3);
+    const response = await publicApiRequest(apiUrl, "POST", "/auth/device/token", {
+      device_code: authorization.device_code
+    });
+    if (response.status === 202 || response.status === 429) {
+      const retryAfter = Number(response.headers.get("retry-after"));
+      if (Number.isFinite(retryAfter) && retryAfter > 0) intervalSeconds = retryAfter;
+      continue;
+    }
+    if (!response.ok) throw new Error(`Login failed: ${await errorMessage(response)}`);
+    const token = await response.json();
+    saveConfig({ api_url: apiUrl, api_key: token.access_token, credential_id: token.credential_id });
+    console.log("Logged in. The credential was stored in ~/.flightdeck/config.json.");
+    return;
+  }
+  throw new Error("Login expired before it was approved. Run `flightdeck login` to try again.");
+}
+
+// src/commands/logout.ts
+async function logout(options) {
+  if (!readConfig()) {
+    console.log("No local FlightDeck login was found.");
+    return;
+  }
+  if (!options.local) {
+    let response;
+    try {
+      response = await apiRequest("POST", "/auth/credential/revoke");
+    } catch (error) {
+      throw new Error(`Credential revocation failed; local login retained: ${String(error)}`);
+    }
+    if (!response.ok && response.status !== 401) {
+      throw new Error(`Credential revocation failed (${response.status}); local login retained.`);
+    }
+  }
+  deleteConfig();
+  console.log(options.local ? "Local login removed." : "Logged out and credential revoked.");
+}
+
+// src/commands/whoami.ts
+async function whoami() {
+  const response = await apiRequest("GET", "/auth/me");
+  if (!response.ok) throw new Error(`Unable to read account (${response.status}).`);
+  console.log(JSON.stringify(await response.json(), null, 2));
+}
+
+// src/commands/balance.ts
+async function balance() {
+  const response = await apiRequest("GET", "/billing/summary");
+  if (!response.ok) throw new Error(`Unable to read credit balance (${response.status}).`);
+  console.log(JSON.stringify(await response.json(), null, 2));
+}
+
+// src/index.ts
+var program = new Command();
+program.name("flightdeck").description("FlightDeck CLI \u2014 submit GPU compute jobs").version(JSON.parse(readFileSync4(new URL("../package.json", import.meta.url), "utf8")).version);
+program.command("login").description("Log in through the FlightDeck portal").option("--api-url <url>", "FlightDeck API URL", DEFAULT_API_URL).option("--name <name>", "name for this CLI credential", "flightdeck-cli").action(login);
+program.command("logout").description("Revoke this CLI credential and remove the local login").option("--local", "remove the local login without revoking the credential").action(logout);
+program.command("whoami").description("Show the current FlightDeck account").action(whoami);
+program.command("balance").description("Show the current credit balance").action(balance);
+program.command("submit").description("Submit a job from local files").argument("<entrypoint>", 'command to run (e.g. "python train.py --epochs 50")').option("-n, --name <name>", "job name", "cli-job").option("-f, --files <glob...>", "files to include (default: current directory)").option("-r, --requirements <file>", "pip requirements file", "requirements.txt").option("--gpu <type>", "GPU type (e.g. A100, H100)").option("--gpu-count <n>", "number of GPUs", "1").option("--time <duration>", "max duration (e.g. 1h, 30m, 3600s)", "1h").option("--base-image <image>", "override base Docker image").option("--provider <id>", "pin the flight to one compute provider (default: operator's order)").option("-e, --env <vars...>", "environment variables (KEY=VALUE)").action(submit);
+program.command("sbatch").description("Submit a Slurm batch script (#SBATCH directives, incl. job arrays)").argument("<script>", "path to the .slurm/.sh batch script").option("-f, --files <glob...>", "files to include (default: current directory)").option("-r, --requirements <file>", "pip requirements file to install before the script runs").option("--base-image <image>", "override base Docker image (e.g. to pin a CUDA version)").option("--provider <id>", "pin every task to one compute provider (default: operator's order)").option("-n, --name <name>", "override job name (default: #SBATCH --job-name)").option("-e, --env <vars...>", "extra environment variables (KEY=VALUE)").option("--dry-run", "parse and show what would be submitted, without submitting").action(async (script, options) => {
+  await sbatch(script, options);
+});
+program.command("slurm-test").description("Run the provider-neutral Slurm conformance workload").option("--timeout <seconds>", "maximum time to wait for all tasks", "1800").option("--poll-interval <seconds>", "status polling interval", "5").action(slurmTest);
+program.command("status").description("Check job status").argument("<flight_id>", "flight ID to check").action(status);
+program.command("logs").description("Stream flight logs").argument("<flight_id>").option("-f, --follow", "follow until complete").action(logs);
+program.command("cancel").description("Cancel a flight").argument("<flight_id>").action(cancel);
+program.command("outputs").description("List flight outputs").argument("<flight_id>").action(listOutputs);
+program.command("download").description("Download all flight outputs").argument("<flight_id>").option("-o, --output-dir <dir>", "destination directory", ".").action(download);
+program.parse();