trainfabric 0.1.24 → 0.1.26

package/dist/index.cjs

@@ -7613,6 +7613,7 @@ var runCreateSchema = external_exports.object({
     repoUrl: external_exports.string().min(1).optional(),
     branch: external_exports.string().min(1).optional(),
     commitSha: external_exports.string().min(1).optional(),
+    entrypoint: external_exports.string().min(1).optional(),
     rootDirName: external_exports.string().min(1).optional(),
     files: external_exports.array(external_exports.object({
       path: external_exports.string().min(1),
@@ -7638,6 +7639,7 @@ var runtimeDetectSchema = external_exports.object({
     repoUrl: external_exports.string().min(1).optional(),
     branch: external_exports.string().min(1).optional(),
     commitSha: external_exports.string().min(1).optional(),
+    entrypoint: external_exports.string().min(1).optional(),
     rootDirName: external_exports.string().min(1).optional(),
     files: external_exports.array(external_exports.object({
       path: external_exports.string().min(1),
@@ -7661,6 +7663,7 @@ var runQuoteSchema = external_exports.object({
     repoUrl: external_exports.string().min(1).optional(),
     branch: external_exports.string().min(1).optional(),
     commitSha: external_exports.string().min(1).optional(),
+    entrypoint: external_exports.string().min(1).optional(),
     rootDirName: external_exports.string().min(1).optional(),
     files: external_exports.array(external_exports.object({
       path: external_exports.string().min(1),
@@ -8817,10 +8820,18 @@ 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) {
   const manifestFiles = /* @__PURE__ */ new Set([
     "training.yaml",
@@ -8868,12 +8879,56 @@ function collectRuntimeFiles(repoPath) {
   walk(repoPath);
   return found.sort((left, right) => left.path.localeCompare(right.path));
 }
+function inferEntrypoint(files) {
+  const trainingYaml = files.find((file) => file.path === "training.yaml" || file.path === "train.runtime.yaml");
+  if (trainingYaml) {
+    const match = trainingYaml.content.match(/entrypoint\s*[:=]\s*["']?([A-Za-z0-9_./-]+)["']?/i);
+    if (match?.[1]) {
+      const entry = match[1];
+      const exact = files.find((file) => file.path === entry);
+      if (exact) {
+        return exact.path;
+      }
+      const nested = files.find((file) => file.path.endsWith(`/${entry}`));
+      if (nested) {
+        return nested.path;
+      }
+      return entry;
+    }
+  }
+  return files.find((file) => /(^|\/)train\.(py|sh)$/i.test(file.path))?.path;
+}
+function validateGitUrl(value) {
+  const url = new URL(value);
+  if (url.protocol !== "https:" && url.protocol !== "http:" && url.protocol !== "ssh:" && url.protocol !== "git:") {
+    throw new Error(`Invalid git URL "${value}". Use an absolute repository URL.`);
+  }
+  return value;
+}
+function validateRepoPath(repoPath) {
+  const absolute = import_node_path2.default.resolve(repoPath);
+  const parsed = import_node_path2.default.parse(absolute);
+  if (absolute === parsed.root || absolute === import_node_os.default.homedir()) {
+    throw new Error(`Refusing to package unsafe repository path: ${repoPath}`);
+  }
+  const stat = import_node_fs.default.statSync(absolute);
+  if (!stat.isDirectory()) {
+    throw new Error(`Repository path must be a directory: ${repoPath}`);
+  }
+  return absolute;
+}
 function buildSourceOptions(options) {
+  if (options.repo && options.git) {
+    throw new Error("Use either --repo or --git, not both.");
+  }
   if (options.repo) {
+    const repoPath = validateRepoPath(options.repo);
+    const files = collectRuntimeFiles(repoPath);
     return {
       source: {
         kind: "inline",
-        files: collectRuntimeFiles(import_node_path2.default.resolve(options.repo))
+        entrypoint: inferEntrypoint(files),
+        files
       }
     };
   }
@@ -8881,7 +8936,7 @@ function buildSourceOptions(options) {
     return {
       source: {
         kind: "git",
-        repoUrl: options.git,
+        repoUrl: validateGitUrl(options.git),
         branch: options.branch
       }
     };
@@ -8910,12 +8965,15 @@ 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}`);
   }
-  return scopes;
+  return [...new Set(scopes)];
 }
 function normalizeHumanName(value, label) {
   let name = String(value ?? "").trim();
@@ -8940,6 +8998,16 @@ function normalizeOptionalId(value, kind, label) {
   }
   return normalizeId(value, kind, label);
 }
+function normalizeOptionalBillingUnit(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const unit = String(value).trim();
+  if (!allowedBillingUnits.has(unit)) {
+    throw new Error("Billing unit is invalid. Use normalized_tflop_seconds, reserved_gpu_seconds, or usd.");
+  }
+  return unit;
+}
 
 // src/run_input.ts
 var BASE_MODEL_ALIASES = {
@@ -8953,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.24";
+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");
@@ -9379,6 +9486,30 @@ function filterQuoteBundleForRequestedMode(bundle, options) {
     quotes: bundle.quotes.filter((item) => item.mode === options.mode || item.quote.mode === options.mode)
   };
 }
+function redactInlineSource(value) {
+  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);
   if (json) {
@@ -9595,11 +9726,12 @@ program2.command("datasets:list").option("--project <projectId>").description("L
   printJson(await createClient(loadConfig()).datasets.list(normalizeOptionalId(options.project, "project", "Project ID")));
 });
 program2.command("datasets:get").argument("<datasetId>").description("Fetch dataset detail").action(async (datasetId) => {
-  printJson(await createClient(loadConfig()).datasets.get(String(datasetId)));
+  printJson(await createClient(loadConfig()).datasets.get(normalizeId(datasetId, "dataset", "Dataset ID")));
 });
 program2.command("datasets:delete").argument("<datasetId>").description("Delete a dataset").action(async (datasetId) => {
-  await createClient(loadConfig()).datasets.delete(String(datasetId));
-  printJson({ deleted: true, id: String(datasetId) });
+  const normalizedDatasetId = normalizeId(datasetId, "dataset", "Dataset ID");
+  await createClient(loadConfig()).datasets.delete(normalizedDatasetId);
+  printJson({ deleted: true, id: normalizedDatasetId });
 });
 program2.command("datasets:upload").argument("<file>").option("--project <projectId>").option("--name <name>").description("Upload a dataset through upload sessions").action(async (file, options) => {
   assertReadableFile(file, "Dataset path");
@@ -9615,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) => {
@@ -9629,12 +9762,11 @@ program2.command("runtime:detect").option("--project <projectId>").option("--rep
     throw new Error("Provide --repo or --git.");
   }
   const config = loadConfig();
-  printJson(
-    await createClient(config).runtime.detect({
-      projectId: requireProjectId(options, config),
-      source: sourceOptions.source
-    })
-  );
+  const detection = await createClient(config).runtime.detect({
+    projectId: requireProjectId(options, config),
+    source: sourceOptions.source
+  });
+  printJson(redactInlineSource(detection));
 });
 program2.command("runtime:build").option("--project <projectId>").requiredOption("--detection <detectionId>").description("Build or reuse a cached runtime image from a runtime detection").action(async (options) => {
   const config = loadConfig();
@@ -9655,31 +9787,32 @@ 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) => {
   printJson(await createClient(loadConfig()).runs.list(normalizeOptionalId(options.project, "project", "Project ID")));
 });
 program2.command("runs:status").argument("<runId>").description("Fetch full run detail").action(async (runId) => {
-  printJson(await createClient(loadConfig()).runs.get(String(runId)));
+  printJson(await createClient(loadConfig()).runs.get(normalizeId(runId, "run", "Run ID")));
 });
 program2.command("runs:logs").argument("<runId>").description("Fetch run logs").action(async (runId) => {
-  printJson(await createClient(loadConfig()).runs.logs(String(runId)));
+  printJson(await createClient(loadConfig()).runs.logs(normalizeId(runId, "run", "Run ID")));
 });
 program2.command("runs:wait").argument("<runId>").option("--timeout <duration>", "maximum wait duration, for example 30s, 10m, or 1h").option("--poll <duration>", "poll interval, for example 1s or 500ms").description("Wait for a run to reach a terminal state").action(async (runId, options) => {
+  const normalizedRunId = normalizeId(runId, "run", "Run ID");
   printJson(
-    await createClient(loadConfig()).runs.wait(String(runId), {
+    await createClient(loadConfig()).runs.wait(normalizedRunId, {
       timeoutMs: parseDurationMs(options.timeout),
       pollMs: parsePositiveMs(options.poll, 1e3)
     })
   );
 });
 program2.command("runs:watch").argument("<runId>").option("--json", "emit event output as JSON").option("--timeout <duration>", "maximum watch duration, for example 30s, 10m, or 1h").option("--poll <duration>", "poll interval, for example 1s or 500ms").description("Stream a run until it completes").action(async (runId, options) => {
-  await watchRun(String(runId), Boolean(options.json), parseDurationMs(options.timeout), parsePositiveMs(options.poll, 1e3));
+  await watchRun(normalizeId(runId, "run", "Run ID"), Boolean(options.json), parseDurationMs(options.timeout), parsePositiveMs(options.poll, 1e3));
 });
 program2.command("runs:usage").argument("<runId>").option("--summary", "print a human-readable cost summary instead of raw JSON").description("Fetch run usage summary").action(async (runId, options) => {
-  const usage = await createClient(loadConfig()).runs.usage(String(runId));
+  const usage = await createClient(loadConfig()).runs.usage(normalizeId(runId, "run", "Run ID"));
   if (options.summary) {
     printUsageSummary(usage);
   } else {
@@ -9687,7 +9820,7 @@ program2.command("runs:usage").argument("<runId>").option("--summary", "print a
   }
 });
 program2.command("runs:cost-breakdown").argument("<runId>").option("--summary", "print a human-readable cost summary instead of raw JSON").description("Fetch realized run cost and profitability").action(async (runId, options) => {
-  const breakdown = await createClient(loadConfig()).runs.costBreakdown(String(runId));
+  const breakdown = await createClient(loadConfig()).runs.costBreakdown(normalizeId(runId, "run", "Run ID"));
   if (options.summary) {
     printUsageSummary(breakdown);
   } else {
@@ -9695,22 +9828,22 @@ program2.command("runs:cost-breakdown").argument("<runId>").option("--summary",
   }
 });
 program2.command("runs:allocation").argument("<runId>").description("Fetch run allocation").action(async (runId) => {
-  printJson(await createClient(loadConfig()).runs.allocation(String(runId)));
+  printJson(await createClient(loadConfig()).runs.allocation(normalizeId(runId, "run", "Run ID")));
 });
 program2.command("runs:configuration").argument("<runId>").description("Fetch run placement configuration").action(async (runId) => {
-  printJson(await createClient(loadConfig()).runs.configuration(String(runId)));
+  printJson(await createClient(loadConfig()).runs.configuration(normalizeId(runId, "run", "Run ID")));
 });
 program2.command("runs:explanation").argument("<runId>").description("Fetch run planning explanation").action(async (runId) => {
-  printJson(await createClient(loadConfig()).runs.explanation(String(runId)));
+  printJson(await createClient(loadConfig()).runs.explanation(normalizeId(runId, "run", "Run ID")));
 });
 program2.command("runs:cancel").argument("<runId>").description("Cancel a run").action(async (runId) => {
-  printJson(await createClient(loadConfig()).runs.cancel(String(runId)));
+  printJson(await createClient(loadConfig()).runs.cancel(normalizeId(runId, "run", "Run ID")));
 });
 program2.command("runs:resume").argument("<runId>").description("Resume a run from the latest checkpoint").action(async (runId) => {
-  printJson(await createClient(loadConfig()).runs.resume(String(runId)));
+  printJson(await createClient(loadConfig()).runs.resume(normalizeId(runId, "run", "Run ID")));
 });
 program2.command("runs:terminate").argument("<runId>").description("Terminate a queued, launchable, or active run").action(async (runId) => {
-  printJson(await createClient(loadConfig()).runs.terminate(String(runId)));
+  printJson(await createClient(loadConfig()).runs.terminate(normalizeId(runId, "run", "Run ID")));
 });
 program2.command("cluster:capacity").description("Fetch cluster capacity view").action(async () => {
   printJson(await createClient(loadConfig()).cluster.getCapacity());
@@ -9722,26 +9855,39 @@ 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());
 });
 program2.command("deployments:create").requiredOption("--model <modelId>").option("--project <projectId>", "accepted for consistency; deployment project is inferred from the model").description("Create a deployment for a model").action(async (options) => {
-  printJson(await createClient(loadConfig()).deployments.create({ modelId: options.model }));
+  const config = loadConfig();
+  const client = createClient(config);
+  const projectId = normalizeOptionalId(options.project, "project", "Project ID");
+  if (projectId) {
+    await client.projects.get(projectId);
+  }
+  const modelId = normalizeId(options.model, "model", "Model ID");
+  printJson(await client.deployments.create({ modelId }));
 });
 program2.command("deployments:get").argument("<deploymentId>").description("Fetch a deployment").action(async (deploymentId) => {
-  printJson(await createClient(loadConfig()).deployments.get(String(deploymentId)));
+  printJson(await createClient(loadConfig()).deployments.get(normalizeId(deploymentId, "deployment", "Deployment ID")));
 });
 program2.command("deployments:delete").argument("<deploymentId>").description("Delete a pending or cataloged deployment").action(async (deploymentId) => {
-  await createClient(loadConfig()).deployments.delete(String(deploymentId));
-  printJson({ deleted: true, id: String(deploymentId) });
+  const normalizedDeploymentId = normalizeId(deploymentId, "deployment", "Deployment ID");
+  await createClient(loadConfig()).deployments.delete(normalizedDeploymentId);
+  printJson({ deleted: true, id: normalizedDeploymentId });
 });
 program2.command("billing:summary").description("Fetch billing summary").action(async () => {
   printJson(await createClient(loadConfig()).billing.getSummary());
 });
 program2.command("billing:usage").option("--unit <unit>", "normalized_tflop_seconds, reserved_gpu_seconds, or usd").option("--run <runId>", "filter usage records to one run").description("List billing usage records").action(async (options) => {
-  printJson(await createClient(loadConfig()).billing.getUsage(options.unit, normalizeOptionalId(options.run, "run", "Run ID")));
+  printJson(
+    await createClient(loadConfig()).billing.getUsage(
+      normalizeOptionalBillingUnit(options.unit),
+      normalizeOptionalId(options.run, "run", "Run ID")
+    )
+  );
 });
 program2.command("billing:invoices").description("List invoices").action(async () => {
   printJson(await createClient(loadConfig()).billing.listInvoices());
@@ -9764,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")
     })
   );
 });
@@ -9785,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(
@@ -9800,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.24",
+  "version": "0.1.26",
   "description": "Trainfabric CLI for launching GPU training jobs on the hosted Trainfabric backend.",
   "type": "module",
   "main": "dist/index.cjs",