@minato-aqukin/autodl-cli 0.1.0

package/dist/chunk-CWCG3MOC.js

@@ -0,0 +1,433 @@
+#!/usr/bin/env node
+import { createRequire as __nodeCreateRequire } from "node:module";
+const require = __nodeCreateRequire(import.meta.url);
+import {
+  UsageError,
+  debug,
+  normalizeBalance,
+  note,
+  warn,
+  yuanToMilli
+} from "./chunk-6QR4ZYQR.js";
+
+// src/core/catalog.ts
+var GPU_SPECS = [
+  {
+    id: "h800",
+    displayName: "H800-80G",
+    tier: "general",
+    vramGb: 80,
+    aliases: ["h800", "h800-80g"],
+    stockName: "H800"
+  },
+  {
+    id: "v-48g",
+    displayName: "4090-48G",
+    tier: "general",
+    vramGb: 48,
+    aliases: ["4090", "4090-48g", "v-48g"],
+    stockName: "vGPU-48GB"
+  },
+  {
+    id: "4090D",
+    displayName: "4090D",
+    tier: "general",
+    vramGb: 24,
+    aliases: ["4090d"],
+    stockName: "RTX 4090D"
+  },
+  {
+    id: "v-48g-350w",
+    displayName: "3090-48G",
+    tier: "general",
+    vramGb: 48,
+    aliases: ["3090", "3090-48g", "v-48g-350w"],
+    stockName: "vGPU-48GB-350W"
+  },
+  {
+    id: "pro6000-p",
+    displayName: "PRO6000-96G",
+    tier: "performance",
+    vramGb: 96,
+    aliases: ["pro6000", "rtx-pro-6000", "pro6000-96g"],
+    stockName: "RTX PRO 6000"
+  },
+  {
+    id: "v-32g-p",
+    displayName: "4080(S)-32G",
+    tier: "performance",
+    vramGb: 32,
+    aliases: ["4080", "4080s", "4080-32g"],
+    stockName: "vGPU-32GB"
+  },
+  {
+    id: "5090-p",
+    displayName: "5090-32G",
+    tier: "performance",
+    vramGb: 32,
+    aliases: ["5090", "5090-32g"],
+    stockName: "RTX 5090"
+  }
+];
+var REGIONS = [
+  {
+    id: "westDC2",
+    displayName: "\u897F\u5317\u4F01\u4E1A\u533A",
+    aliases: ["west2", "\u897F\u5317\u4F01\u4E1A\u533A", "\u897F\u5317\u4F01\u4E1A"],
+    proCreate: false
+  },
+  {
+    id: "westDC3",
+    displayName: "\u897F\u5317B\u533A",
+    aliases: ["west3", "\u897F\u5317b\u533A", "\u897F\u5317b"],
+    proCreate: true
+  },
+  {
+    id: "beijingDC1",
+    displayName: "\u5317\u4EACA\u533A",
+    aliases: ["bj1", "\u5317\u4EACa\u533A", "\u5317\u4EACa"],
+    proCreate: false
+  },
+  {
+    id: "beijingDC2",
+    displayName: "\u5317\u4EACB\u533A",
+    aliases: ["bj2", "\u5317\u4EACb\u533A", "\u5317\u4EACb"],
+    proCreate: true
+  },
+  {
+    id: "beijingDC3",
+    displayName: "V100\u4E13\u533A",
+    aliases: ["bj3", "v100", "v100\u4E13\u533A"],
+    proCreate: false
+  },
+  {
+    id: "beijingDC4",
+    displayName: "L20\u4E13\u533A",
+    aliases: ["bj4", "l20", "l20\u4E13\u533A"],
+    proCreate: false
+  },
+  {
+    id: "neimengDC1",
+    displayName: "\u5185\u8499A\u533A",
+    aliases: ["nm1", "\u5185\u8499a\u533A", "\u5185\u8499a"],
+    proCreate: false
+  },
+  {
+    id: "neimengDC3",
+    displayName: "\u5185\u8499B\u533A",
+    aliases: ["nm3", "\u5185\u8499b\u533A", "\u5185\u8499b"],
+    proCreate: false
+  },
+  { id: "foshanDC1", displayName: "\u4F5B\u5C71\u533A", aliases: ["fs1", "\u4F5B\u5C71"], proCreate: false },
+  {
+    id: "chongqingDC1",
+    displayName: "\u91CD\u5E86A\u533A",
+    aliases: ["cq1", "\u91CD\u5E86a\u533A", "\u91CD\u5E86"],
+    proCreate: false
+  },
+  {
+    id: "yangzhouDC1",
+    displayName: "3090\u4E13\u533A",
+    aliases: ["yz1", "3090\u4E13\u533A", "\u626C\u5DDE"],
+    proCreate: false
+  }
+];
+var BASE_IMAGES = [
+  {
+    uuid: "base-image-l2t43iu6uk",
+    framework: "PyTorch",
+    tag: "cuda11.8-cudnn8-devel-ubuntu20.04-py38-torch2.0.0",
+    cuda: "11.8",
+    python: "3.8"
+  },
+  {
+    uuid: "base-image-l374uiucui",
+    framework: "PyTorch",
+    tag: "cuda11.3-cudnn8-devel-ubuntu20.04-py38-torch1.11.0",
+    cuda: "11.3",
+    python: "3.8"
+  },
+  {
+    uuid: "base-image-u9r24vthlk",
+    framework: "PyTorch",
+    tag: "cuda11.3-cudnn8-devel-ubuntu20.04-py38-torch1.10.0",
+    cuda: "11.3",
+    python: "3.8"
+  },
+  {
+    uuid: "base-image-12be412037",
+    framework: "PyTorch",
+    tag: "cuda11.1-cudnn8-devel-ubuntu18.04-py38-torch1.9.0",
+    cuda: "11.1",
+    python: "3.8"
+  },
+  {
+    uuid: "base-image-uxeklgirir",
+    framework: "TensorFlow",
+    tag: "cuda11.2-cudnn8-devel-ubuntu20.04-py38-tf2.9.0",
+    cuda: "11.2",
+    python: "3.8"
+  },
+  {
+    uuid: "base-image-0gxqmciyth",
+    framework: "TensorFlow",
+    tag: "cuda11.2-cudnn8-devel-ubuntu18.04-py38-tf2.5.0",
+    cuda: "11.2",
+    python: "3.8"
+  },
+  {
+    uuid: "base-image-4bpg0tt88l",
+    framework: "TensorFlow",
+    tag: "cuda11.4-py38-tf1.15.5",
+    cuda: "11.4",
+    python: "3.8"
+  },
+  {
+    uuid: "base-image-mbr2n4urrc",
+    framework: "Miniconda",
+    tag: "cuda11.6-cudnn8-devel-ubuntu20.04-py38",
+    cuda: "11.6",
+    python: "3.8"
+  },
+  {
+    uuid: "base-image-7bn8iqhkb5",
+    framework: "Miniconda",
+    tag: "cudagl11.3-cudnn8-devel-ubuntu20.04-py38",
+    cuda: "11.3",
+    python: "3.8"
+  },
+  {
+    uuid: "base-image-h041hn36yt",
+    framework: "Miniconda",
+    tag: "cuda11.1-cudnn8-devel-ubuntu18.04-py38",
+    cuda: "11.1",
+    python: "3.8"
+  },
+  {
+    uuid: "base-image-qkkhitpik5",
+    framework: "Miniconda",
+    tag: "cuda10.2-cudnn7-devel-ubuntu18.04-py38",
+    cuda: "10.2",
+    python: "3.8"
+  },
+  {
+    uuid: "base-image-k0vep6kyq8",
+    framework: "Miniconda",
+    tag: "cuda9.0-cudnn7-devel-ubuntu16.04-py36",
+    cuda: "9.0",
+    python: "3.6"
+  },
+  {
+    uuid: "base-image-l2843iu23k",
+    framework: "TensorRT",
+    tag: "cuda11.8-cudnn8-devel-ubuntu20.04-py38-trt8.5.1",
+    cuda: "11.8",
+    python: "3.8"
+  }
+];
+var DEFAULT_BASE_IMAGE = "base-image-l2t43iu6uk";
+function norm(value) {
+  return value.trim().toLowerCase();
+}
+function resolveGpuSpec(input) {
+  const needle = norm(input);
+  return GPU_SPECS.find(
+    (spec) => norm(spec.id) === needle || norm(spec.displayName) === needle || spec.aliases.some((alias) => norm(alias) === needle)
+  );
+}
+function resolveRegion(input) {
+  const needle = norm(input);
+  return REGIONS.find(
+    (region) => norm(region.id) === needle || norm(region.displayName) === needle || region.aliases.some((alias) => norm(alias) === needle)
+  );
+}
+function assertStockRegion(input) {
+  const region = resolveRegion(input);
+  if (!region) {
+    throw new UsageError(`\u672A\u77E5\u7684\u5730\u533A "${input}"`, {
+      hint: "\u8FD0\u884C `autodl regions` \u67E5\u770B\u6709\u6548\u5730\u533A\u4EE3\u7801\u3002\u6CE8\u610F\u5B9E\u4F8B\u8FD4\u56DE\u7684 region_sign\uFF08\u5982 bj-B2\uFF09\u4E0E\u8FD9\u91CC\u7684\u5730\u533A\u4EE3\u7801\uFF08\u5982 beijingDC2\uFF09\u4E0D\u662F\u540C\u4E00\u5957\u547D\u540D\uFF0C\u4E0D\u80FD\u6DF7\u7528\u3002"
+    });
+  }
+  return region;
+}
+var PRO_CREATE_REGIONS = REGIONS.filter((region) => region.proCreate);
+function assertProCreateRegion(input) {
+  const region = assertStockRegion(input);
+  if (!region.proCreate) {
+    throw new UsageError(`\u5730\u533A "${region.displayName}"\uFF08${region.id}\uFF09\u4E0D\u652F\u6301\u521B\u5EFA Pro \u5B9E\u4F8B`, {
+      hint: `\u5B98\u65B9\u5F00\u653E API \u53EA\u80FD\u5728 ${PRO_CREATE_REGIONS.map((r) => `${r.displayName}(${r.id})`).join(" \u6216 ")} \u521B\u5EFA\u5B9E\u4F8B\uFF1B\u5176\u4F59\u5730\u533A\u4EC5\u7528\u4E8E\u5F39\u6027\u90E8\u7F72\u3002\u4E0D\u6307\u5B9A --region \u65F6\u7531 AutoDL \u81EA\u884C\u8C03\u5EA6\uFF0C\u6210\u529F\u7387\u66F4\u9AD8\u3002`
+    });
+  }
+  return region;
+}
+function findBaseImage(input) {
+  const needle = norm(input);
+  return BASE_IMAGES.find((image) => norm(image.uuid) === needle || norm(image.tag) === needle);
+}
+function parseCudaVersion(input) {
+  if (typeof input === "number") return input >= 100 ? input : Math.round(input * 10);
+  const trimmed = input.trim();
+  if (/^\d{3}$/.test(trimmed)) return Number(trimmed);
+  const asFloat = Number.parseFloat(trimmed);
+  if (Number.isNaN(asFloat)) return 0;
+  const [major = "0", minor = "0"] = trimmed.split(".");
+  return Number(major) * 10 + Number(minor.slice(0, 1) || "0");
+}
+function formatCudaVersion(value) {
+  if (!value) return "-";
+  return `${Math.floor(value / 10)}.${value % 10}`;
+}
+
+// src/core/endpoints/account.ts
+async function getBalance(client) {
+  const data = await client.post("/api/v1/dev/wallet/balance", {});
+  return normalizeBalance(data);
+}
+async function setNfsMount(client, dataCenter, mount) {
+  await client.post("/api/v1/dev/exclusive_nfs/mount", {
+    data_center: dataCenter,
+    mountable: mount ? 1 : -1
+  });
+}
+
+// src/core/endpoints/machine.ts
+async function getRegionGpuStock(client, query) {
+  const region = assertStockRegion(query.regionSign);
+  const payload = { region_sign: region.id };
+  if (query.gpuNames?.length) payload.gpu_name_set = query.gpuNames;
+  if (query.cudaFrom !== void 0) payload.cuda_v_from = query.cudaFrom;
+  if (query.cudaTo !== void 0) payload.cuda_v_to = query.cudaTo;
+  if (query.cpuNumFrom !== void 0) payload.cpu_num_from = query.cpuNumFrom;
+  if (query.cpuNumTo !== void 0) payload.cpu_num_to = query.cpuNumTo;
+  if (query.memorySizeFrom !== void 0) payload.memory_size_from = query.memorySizeFrom;
+  if (query.memorySizeTo !== void 0) payload.memory_size_to = query.memorySizeTo;
+  if (query.priceFromYuan !== void 0) payload.price_from = yuanToMilli(query.priceFromYuan);
+  if (query.priceToYuan !== void 0) payload.price_to = yuanToMilli(query.priceToYuan);
+  const data = await client.post("/api/v1/dev/machine/region/gpu_stock", payload);
+  const entries = [];
+  for (const item of Array.isArray(data) ? data : []) {
+    for (const [gpuName, value] of Object.entries(item ?? {})) {
+      entries.push({
+        gpuName,
+        idle: value?.idle_gpu_num ?? 0,
+        total: value?.total_gpu_num ?? 0,
+        chipCorp: value?.chip_corp ?? null,
+        cpuArch: value?.cpu_arch ?? null
+      });
+    }
+  }
+  return entries;
+}
+
+// src/core/stock.ts
+async function getStockByRegion(client, options = {}) {
+  const targets = (options.regions?.length ? options.regions : REGIONS.map((r) => r.id)).map(
+    (input) => assertStockRegion(input)
+  );
+  const settled = await Promise.allSettled(
+    targets.map(async (region) => ({
+      region,
+      entries: await getRegionGpuStock(client, {
+        regionSign: region.id,
+        ...options.gpuNames?.length ? { gpuNames: options.gpuNames } : {}
+      })
+    }))
+  );
+  const snapshots = [];
+  const failures = [];
+  settled.forEach((result, index) => {
+    const region = targets[index];
+    if (!region) return;
+    if (result.status === "fulfilled") {
+      snapshots.push({
+        regionId: region.id,
+        regionName: region.displayName,
+        entries: result.value.entries
+      });
+    } else {
+      const reason = result.reason?.message ?? String(result.reason);
+      failures.push({ regionId: region.id, reason });
+      debug(`\u67E5\u8BE2 ${region.id} \u5E93\u5B58\u5931\u8D25\uFF1A${reason}`);
+    }
+  });
+  return { snapshots, failures };
+}
+async function findRegionsWithStock(client, spec, options = {}) {
+  const { snapshots, failures } = await getStockByRegion(client, {
+    ...options.regions?.length ? { regions: options.regions } : {},
+    gpuNames: [spec.stockName]
+  });
+  const ranked = [];
+  for (const snapshot of snapshots) {
+    const entry = snapshot.entries.find((e) => e.gpuName === spec.stockName);
+    if (!entry) continue;
+    ranked.push({
+      regionId: snapshot.regionId,
+      regionName: snapshot.regionName,
+      idle: entry.idle,
+      total: entry.total
+    });
+  }
+  ranked.sort((a, b) => b.idle - a.idle || b.total - a.total);
+  return { ranked, failures };
+}
+function specForStockName(gpuName) {
+  return GPU_SPECS.find((spec) => spec.stockName === gpuName);
+}
+async function chooseRegions(client, spec, requested) {
+  if (!requested?.length) {
+    return { regions: [], ranked: [], allBusy: false };
+  }
+  const validated = requested.map((input) => assertProCreateRegion(input).id);
+  const { ranked, failures } = await findRegionsWithStock(client, spec, { regions: validated });
+  for (const failure of failures) debug(`\u5E93\u5B58\u67E5\u8BE2\u5931\u8D25 ${failure.regionId}\uFF1A${failure.reason}`);
+  const withStock = ranked.filter((region) => region.idle > 0);
+  if (withStock.length === 0 && ranked.length > 0) {
+    warn(
+      `${spec.displayName} \u5728\u6307\u5B9A\u5730\u533A\u7684\u5F39\u6027\u90E8\u7F72\u5E93\u5B58\u4E3A 0\uFF0C\u4ECD\u4F1A\u5C1D\u8BD5\u521B\u5EFA\uFF08\u8BE5\u5E93\u5B58\u4E0D\u53CD\u6620 Pro \u5B9E\u4F8B\u53EF\u7528\u91CF\uFF0C\u4EC5\u4F9B\u53C2\u8003\uFF09`
+    );
+    return { regions: validated, ranked, allBusy: true };
+  }
+  if (withStock.length > 0) {
+    const best = withStock[0];
+    note(
+      `\u6307\u5B9A\u5730\u533A\u4E2D ${best.regionName} \u5E93\u5B58\u6700\u591A\uFF08${spec.displayName} \u7A7A\u95F2 ${best.idle}/${best.total}\uFF09`
+    );
+    const ordered = [
+      ...withStock.map((region) => region.regionId),
+      ...validated.filter((id) => !withStock.some((region) => region.regionId === id))
+    ];
+    return { regions: ordered, ranked, allBusy: false };
+  }
+  return { regions: validated, ranked, allBusy: false };
+}
+
+// src/version.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var VERSION = pkg.version;
+
+export {
+  GPU_SPECS,
+  REGIONS,
+  BASE_IMAGES,
+  DEFAULT_BASE_IMAGE,
+  resolveGpuSpec,
+  resolveRegion,
+  assertStockRegion,
+  PRO_CREATE_REGIONS,
+  assertProCreateRegion,
+  findBaseImage,
+  parseCudaVersion,
+  formatCudaVersion,
+  getBalance,
+  setNfsMount,
+  getRegionGpuStock,
+  getStockByRegion,
+  findRegionsWithStock,
+  specForStockName,
+  chooseRegions,
+  VERSION
+};
+//# sourceMappingURL=chunk-CWCG3MOC.js.map

package/dist/chunk-NBWWTYSL.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import { createRequire as __nodeCreateRequire } from "node:module";
+const require = __nodeCreateRequire(import.meta.url);
+import {
+  AutoDLClient,
+  configureOutput,
+  debug,
+  resolveBaseUrl,
+  resolveLang,
+  resolveToken,
+  setLang,
+  sweepExpired
+} from "./chunk-6QR4ZYQR.js";
+
+// src/context.ts
+function createContext(options = {}) {
+  const lang = resolveLang(options.lang);
+  setLang(lang);
+  configureOutput({
+    json: options.json ?? false,
+    color: options.color ?? true,
+    verbose: options.verbose ?? false
+  });
+  const { token, source } = resolveToken(options.token);
+  debug(`Token \u6765\u6E90\uFF1A${source}`);
+  const client = new AutoDLClient({
+    token,
+    ...resolveBaseUrl(options.baseUrl) ? { baseUrl: resolveBaseUrl(options.baseUrl) } : {},
+    onDebug: debug
+  });
+  return { client, lang };
+}
+async function runOpportunisticSweep(context, options) {
+  if (options.sweep === false || process.env.AUTODL_NO_SWEEP === "1") return;
+  try {
+    await sweepExpired(context.client);
+  } catch (err) {
+    debug(`TTL \u6E05\u7406\u5931\u8D25\uFF08\u5DF2\u5FFD\u7565\uFF09\uFF1A${err.message}`);
+  }
+}
+
+export {
+  createContext,
+  runOpportunisticSweep
+};
+//# sourceMappingURL=chunk-NBWWTYSL.js.map