trainfabric 0.1.25 → 0.1.26

package/dist/index.cjs

@@ -8820,12 +8820,16 @@ var import_node_fs = __toESM(require("node:fs"), 1);
 var import_node_os = __toESM(require("node:os"), 1);
 var import_node_path2 = __toESM(require("node:path"), 1);
 var idPatterns = {
+  apiKey: /^key_[A-Za-z0-9_-]+$/,
   dataset: /^ds_[A-Za-z0-9_-]+$/,
   deployment: /^dep_[A-Za-z0-9_-]+$/,
   model: /^mdl_[A-Za-z0-9_-]+$/,
   org: /^org_[A-Za-z0-9_-]+$/,
+  pool: /^pool_[A-Za-z0-9_-]+$/,
   project: /^proj_[A-Za-z0-9_-]+$/,
-  run: /^run_[A-Za-z0-9_-]+$/
+  run: /^run_[A-Za-z0-9_-]+$/,
+  serviceAccount: /^svc_[A-Za-z0-9_-]+$/,
+  supplier: /^[A-Za-z][A-Za-z0-9_-]*$/
 };
 var allowedBillingUnits = /* @__PURE__ */ new Set(["normalized_tflop_seconds", "reserved_gpu_seconds", "usd"]);
 function collectRuntimeFiles(repoPath) {
@@ -8961,7 +8965,10 @@ function decrypt(payload) {
 }
 function parseApiKeyScopes(input) {
   const allowedScopes = new Set(apiKeyScopes);
-  const scopes = input.split(",").map((scope) => scope.trim()).filter(Boolean);
+  const scopes = input.split(",").map((scope) => scope.trim());
+  if (scopes.some((scope) => scope.length === 0)) {
+    throw new Error("API key scopes cannot contain empty entries.");
+  }
   const invalidScope = scopes.find((scope) => !allowedScopes.has(scope));
   if (invalidScope) {
     throw new Error(`Invalid API key scope: ${invalidScope}`);
@@ -9014,36 +9021,75 @@ var BASE_MODEL_ALIASES = {
   "qwen2.5-7b": "qwen-2.5-7b",
   qwen_2_5_7b: "qwen-2.5-7b"
 };
+var ACCELERATOR_CLASSES = /* @__PURE__ */ new Set(["a10g", "l4", "a40", "l40s", "a100", "h100", "h200", "b200"]);
+var PRECISION_MODES = /* @__PURE__ */ new Set(["fp16_bf16", "fp8", "fp32"]);
+var INTERCONNECT_TYPES = /* @__PURE__ */ new Set(["pcie", "nvlink"]);
+function normalizePositiveInteger(value, label, fallback) {
+  const parsed = Number(value ?? String(fallback));
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`${label} must be a positive integer.`);
+  }
+  return parsed;
+}
+function normalizeOptionalPositiveNumber(value, label) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${label} must be a positive number.`);
+  }
+  return parsed;
+}
+function normalizeOptionalChoice(value, allowed, label, examples) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const normalized = String(value).trim().toLowerCase();
+  if (!allowed.has(normalized)) {
+    throw new Error(`${label} is invalid. Use ${examples}.`);
+  }
+  return normalized;
+}
 function normalizeBaseModel(model) {
   return BASE_MODEL_ALIASES[model] ?? model;
 }
 function buildComputeSpec(options) {
-  const gpuCount = Number(options.gpus ?? "1");
-  const nodeCount = Number(options.nodes ?? "1");
+  const gpuCount = normalizePositiveInteger(options.gpus, "GPU count", 1);
+  const nodeCount = normalizePositiveInteger(options.nodes, "Node count", 1);
   const compute = {
     gpuCount,
     nodeCount,
     distributionStrategy: gpuCount > 1 || nodeCount > 1 ? "ddp" : "single_gpu",
     target: "local"
   };
-  if (options.accelerator) {
-    compute.acceleratorClass = options.accelerator;
+  const accelerator = normalizeOptionalChoice(
+    options.accelerator,
+    ACCELERATOR_CLASSES,
+    "Accelerator",
+    "a10g, l4, a40, l40s, a100, h100, h200, or b200"
+  );
+  const minMemory = normalizeOptionalPositiveNumber(options.minMemory, "Minimum GPU memory");
+  const precision = normalizeOptionalChoice(options.precision, PRECISION_MODES, "Precision", "fp16_bf16, fp8, or fp32");
+  const interconnect = normalizeOptionalChoice(options.interconnect, INTERCONNECT_TYPES, "Interconnect", "pcie or nvlink");
+  if (accelerator) {
+    compute.acceleratorClass = accelerator;
   }
-  if (options.minMemory) {
-    compute.minGpuMemoryGb = Number(options.minMemory);
+  if (minMemory !== void 0) {
+    compute.minGpuMemoryGb = minMemory;
   }
-  if (options.precision) {
-    compute.precision = options.precision;
+  if (precision) {
+    compute.precision = precision;
   }
-  if (options.interconnect) {
-    compute.interconnect = options.interconnect;
+  if (interconnect) {
+    compute.interconnect = interconnect;
   }
   return compute;
 }
 
 // src/index.ts
 var DEFAULT_TRAINFABRIC_API_URL2 = "https://api.trainfabric.com";
-var CLI_VERSION = "0.1.25";
+var CLI_VERSION = "0.1.26";
 var CONFIG_DIR = import_node_path3.default.join(import_node_os2.default.homedir(), ".trainfabric");
 var CONFIG_PATH = import_node_path3.default.join(CONFIG_DIR, "config.json");
 var FALLBACK_SECRET_PATH = import_node_path3.default.join(CONFIG_DIR, "session.enc");
@@ -9441,14 +9487,28 @@ function filterQuoteBundleForRequestedMode(bundle, options) {
   };
 }
 function redactInlineSource(value) {
-  return JSON.parse(
-    JSON.stringify(value, (_key, current) => {
-      if (current && typeof current === "object" && typeof current.path === "string" && typeof current.content === "string") {
-        return { ...current, content: "<redacted>" };
-      }
+  const redact = (current) => {
+    if (Array.isArray(current)) {
+      return current.map((item) => redact(item));
+    }
+    if (!current || typeof current !== "object") {
       return current;
-    })
-  );
+    }
+    const object = current;
+    const next = {};
+    for (const [key, child] of Object.entries(object)) {
+      next[key] = key === "content" && typeof child === "string" ? "<redacted>" : redact(child);
+    }
+    return next;
+  };
+  return redact(value);
+}
+function normalizePositiveUsd(value, label) {
+  const amount = Number(value);
+  if (!Number.isFinite(amount) || amount <= 0) {
+    throw new Error(`${label} must be a positive USD amount.`);
+  }
+  return amount;
 }
 async function watchRun(runId, json = false, timeoutMs, pollMs) {
   const handle = await createClient(loadConfig()).runs.watch(runId);
@@ -9687,12 +9747,13 @@ program2.command("datasets:upload").argument("<file>").option("--project <projec
   printJson(dataset);
 });
 program2.command("runs:create").option("--project <projectId>").requiredOption("--dataset <datasetId>").requiredOption("--model <baseModel>").option("--eval <evalDatasetId>").option("--epochs <epochs>", "number of epochs", "3").option("--lr <lr>", "learning rate", "0.0002").option("--gpus <gpuCount>", "gpu count", "1").option("--nodes <nodeCount>", "node count", "1").option("--accelerator <acceleratorClass>", "optional hard accelerator constraint (for example: a10g, a100, h100)").option("--min-memory <gigabytes>", "minimum GPU memory in GB").option("--precision <precision>", "fp16_bf16, fp8, or fp32").option("--interconnect <interconnect>", "pcie or nvlink").option("--mode <mode>", "efficient, balanced, or power", "balanced").option("--quote <pricingQuoteId>", "launch the exact accepted quote id from runs:quote").option("--repo <path>", "local repo path for runtime autodetect").option("--git <url>", "git repo URL for runtime metadata").option("--branch <branch>", "git branch for runtime metadata").option("--yes", "confirm that you reviewed pricing with runs:quote --summary and accept fluctuating realized usage").description("Create a training run").action(async (options) => {
+  const config = loadConfig();
+  const runInput = buildRunInput(options, config);
   if (!options.yes) {
     throw new Error("Refusing to launch without explicit cost acceptance. Run `trainfabric runs:quote --summary ...` first, then rerun `runs:create` with --yes.");
   }
-  const config = loadConfig();
   const client = createClient(config);
-  const run = await client.runs.create(buildRunInput(options, config));
+  const run = await client.runs.create(runInput);
   printJson(run.snapshot);
 });
 program2.command("runtime:detect").option("--project <projectId>").option("--repo <path>").option("--git <url>").option("--branch <branch>").description("Detect a supported runtime from a local repo snapshot or git metadata").action(async (options) => {
@@ -9726,7 +9787,7 @@ program2.command("runs:quote").option("--project <projectId>").requiredOption("-
   if (options.summary) {
     printQuoteSummary(bundle);
   } else {
-    printJson(bundle);
+    printJson(redactInlineSource(bundle));
   }
 });
 program2.command("runs:list").option("--project <projectId>").description("List runs").action(async (options) => {
@@ -9794,7 +9855,7 @@ program2.command("models:list").description("List exported models").action(async
   printJson(await createClient(loadConfig()).models.list());
 });
 program2.command("models:export").argument("<modelId>").description("Fetch the export package path for a model").action(async (modelId) => {
-  printJson(await createClient(loadConfig()).models.export(String(modelId)));
+  printJson(await createClient(loadConfig()).models.export(normalizeId(modelId, "model", "Model ID")));
 });
 program2.command("deployments:list").description("List deployments").action(async () => {
   printJson(await createClient(loadConfig()).deployments.list());
@@ -9849,9 +9910,9 @@ program2.command("treasury:funding").description("List supplier funding summarie
 program2.command("treasury:funding-preview").requiredOption("--estimated-supplier-cost <usd>").option("--supplier <supplierId>").option("--pool <poolId>").description("Preview treasury funding readiness for a supplier-backed launch").action(async (options) => {
   printJson(
     await createClient(loadConfig()).treasury.previewFunding({
-      estimatedSupplierCostUsd: Number(options.estimatedSupplierCost),
-      poolId: options.pool,
-      supplier: options.supplier
+      estimatedSupplierCostUsd: normalizePositiveUsd(options.estimatedSupplierCost, "Estimated supplier cost"),
+      poolId: normalizeOptionalId(options.pool, "pool", "Pool ID"),
+      supplier: normalizeOptionalId(options.supplier, "supplier", "Supplier ID")
     })
   );
 });
@@ -9870,8 +9931,9 @@ program2.command("api-keys:list").description("List API keys").action(async () =
   printJson(await createClient(loadConfig()).apiKeys.list());
 });
 program2.command("api-keys:revoke").argument("<apiKeyId>").description("Revoke an API key").action(async (apiKeyId) => {
-  await createClient(loadConfig()).apiKeys.revoke(String(apiKeyId));
-  console.log(`Revoked API key ${String(apiKeyId)}.`);
+  const normalizedApiKeyId = normalizeId(apiKeyId, "apiKey", "API key ID");
+  await createClient(loadConfig()).apiKeys.revoke(normalizedApiKeyId);
+  console.log(`Revoked API key ${normalizedApiKeyId}.`);
 });
 program2.command("service-accounts:create").requiredOption("--name <name>").option("--scopes <scopes>", "comma-separated scopes", "org:read,project:read,project:write,dataset:read,dataset:write,run:read,run:write").description("Create a service account").action(async (options) => {
   printJson(
@@ -9885,8 +9947,9 @@ program2.command("service-accounts:list").description("List service accounts").a
   printJson(await createClient(loadConfig()).serviceAccounts.list());
 });
 program2.command("service-accounts:revoke").argument("<serviceAccountId>").description("Revoke a service account").action(async (serviceAccountId) => {
-  await createClient(loadConfig()).serviceAccounts.revoke(String(serviceAccountId));
-  console.log(`Revoked service account ${String(serviceAccountId)}.`);
+  const normalizedServiceAccountId = normalizeId(serviceAccountId, "serviceAccount", "Service account ID");
+  await createClient(loadConfig()).serviceAccounts.revoke(normalizedServiceAccountId);
+  console.log(`Revoked service account ${normalizedServiceAccountId}.`);
 });
 void program2.parseAsync(process.argv).catch((error) => {
   console.error(error instanceof Error ? error.message : String(error));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trainfabric",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "description": "Trainfabric CLI for launching GPU training jobs on the hosted Trainfabric backend.",
   "type": "module",
   "main": "dist/index.cjs",