@minato-aqukin/autodl-cli 0.1.0

package/dist/chunk-5RZ4Q7T4.js

@@ -0,0 +1,1458 @@
+#!/usr/bin/env node
+import { createRequire as __nodeCreateRequire } from "node:module";
+const require = __nodeCreateRequire(import.meta.url);
+import {
+  BASE_IMAGES,
+  DEFAULT_BASE_IMAGE,
+  GPU_SPECS,
+  REGIONS,
+  VERSION,
+  assertProCreateRegion,
+  chooseRegions,
+  findBaseImage,
+  getBalance,
+  getStockByRegion,
+  parseCudaVersion,
+  resolveGpuSpec,
+  resolveRegion
+} from "./chunk-CWCG3MOC.js";
+import {
+  createContext
+} from "./chunk-NBWWTYSL.js";
+import {
+  AutoDLError,
+  BudgetError,
+  SSHError,
+  UsageError,
+  armTTLOverSSH,
+  composeStartCommand,
+  createInstance,
+  debug,
+  execCommand,
+  findInstance,
+  formatDuration,
+  formatYuan,
+  getCredentials,
+  getInstanceSnapshot,
+  getInstanceStatus,
+  isJson,
+  listAllInstances,
+  normalizeImage,
+  normalizePagination,
+  note,
+  parseDuration,
+  powerOffInstance,
+  powerOnInstance,
+  readConfig,
+  recordTTL,
+  redactSnapshot,
+  releaseInstance,
+  success,
+  sweepExpired,
+  t,
+  toAutoDLError,
+  untrackInstance,
+  waitForRunning,
+  waitForShutdown,
+  warn,
+  withSSH
+} from "./chunk-6QR4ZYQR.js";
+
+// src/core/endpoints/image.ts
+async function saveImage(client, instanceUuid, imageName) {
+  const data = await client.post(
+    "/api/v1/dev/instance/pro/image/save",
+    { instance_uuid: instanceUuid, image_name: imageName },
+    { maxRetries: 0 }
+  );
+  return data.image_uuid;
+}
+async function listPrivateImages(client, options = {}) {
+  const data = await client.post(
+    "/api/v1/dev/instance/pro/image/private/list",
+    { page_index: options.pageIndex ?? 1, page_size: options.pageSize ?? 50 }
+  );
+  const list = Array.isArray(data?.list) ? data.list : [];
+  return { images: list.map(normalizeImage), pagination: normalizePagination(data) };
+}
+
+// src/core/repo.ts
+var ACCELERATED_HOSTS = /* @__PURE__ */ new Set([
+  "github.com",
+  "raw.githubusercontent.com",
+  "githubusercontent.com",
+  "githubassets.com",
+  "huggingface.co"
+]);
+var SCP_LIKE = /^(?:([^@]+)@)?([^:/]+):(.+)$/;
+function parseRepo(input) {
+  const trimmed = input.trim();
+  if (!trimmed) throw new UsageError("\u4ED3\u5E93\u5730\u5740\u4E0D\u80FD\u4E3A\u7A7A");
+  let host;
+  let path;
+  if (/^https?:\/\//i.test(trimmed)) {
+    let url;
+    try {
+      url = new URL(trimmed);
+    } catch {
+      throw new UsageError(`\u65E0\u6CD5\u89E3\u6790\u4ED3\u5E93\u5730\u5740 "${input}"`);
+    }
+    host = url.hostname;
+    path = url.pathname;
+  } else if (trimmed.startsWith("git@") || SCP_LIKE.test(trimmed)) {
+    const match = SCP_LIKE.exec(trimmed);
+    if (!match) throw new UsageError(`\u65E0\u6CD5\u89E3\u6790\u4ED3\u5E93\u5730\u5740 "${input}"`);
+    host = match[2];
+    path = match[3];
+  } else if (/^[\w.-]+\/[\w.-]+$/.test(trimmed)) {
+    host = "github.com";
+    path = trimmed;
+  } else {
+    throw new UsageError(`\u65E0\u6CD5\u89E3\u6790\u4ED3\u5E93\u5730\u5740 "${input}"`, {
+      hint: "\u652F\u6301 https://github.com/owner/repo\u3001git@github.com:owner/repo.git \u6216 owner/repo\u3002"
+    });
+  }
+  path = path.replace(/^\/+/, "").replace(/\/+$/, "").replace(/\.git$/i, "");
+  if (!path?.includes("/")) {
+    throw new UsageError(`\u4ED3\u5E93\u5730\u5740\u7F3A\u5C11 owner/name\uFF1A"${input}"`);
+  }
+  const name = path.split("/").pop();
+  return {
+    host,
+    path,
+    name,
+    cloneUrl: `https://${host}/${path}.git`,
+    needsAcceleration: ACCELERATED_HOSTS.has(host)
+  };
+}
+function withCredentials(repo, token) {
+  if (!token) return { url: repo.cloneUrl, display: repo.cloneUrl };
+  return {
+    url: `https://x-access-token:${token}@${repo.host}/${repo.path}.git`,
+    display: `https://x-access-token:***@${repo.host}/${repo.path}.git`
+  };
+}
+function redactCredentials(text) {
+  return text.replace(/(https?:\/\/)([^/@\s]+)@/gi, "$1***@");
+}
+function resolveGitToken(explicit) {
+  const candidate = explicit ?? process.env.GIT_TOKEN ?? process.env.GITHUB_TOKEN ?? process.env.GITEE_TOKEN;
+  return candidate?.trim() ? candidate.trim() : void 0;
+}
+
+// src/guard/budget.ts
+var DEFAULT_MIN_BALANCE_YUAN = 5;
+function resolveMinBalance(explicit) {
+  if (explicit !== void 0) return explicit;
+  const fromEnv = Number(process.env.AUTODL_MIN_BALANCE);
+  if (!Number.isNaN(fromEnv) && process.env.AUTODL_MIN_BALANCE) return fromEnv;
+  return readConfig().defaults?.minBalanceYuan ?? DEFAULT_MIN_BALANCE_YUAN;
+}
+async function assertBudget(client, minYuan) {
+  const threshold = resolveMinBalance(minYuan);
+  if (threshold <= 0) {
+    debug("\u4F59\u989D\u95F8\u95E8\u5DF2\u7981\u7528\uFF08\u9608\u503C <= 0\uFF09");
+    return Number.POSITIVE_INFINITY;
+  }
+  const balance = await getBalance(client);
+  const spendable = balance.balanceYuan + balance.voucherYuan;
+  debug(`\u4F59\u989D\u68C0\u67E5\uFF1A\u53EF\u7528 ${formatYuan(spendable)}\uFF0C\u9608\u503C ${formatYuan(threshold)}`);
+  if (spendable < threshold) {
+    throw new BudgetError(
+      `\u8D26\u53F7\u53EF\u7528\u4F59\u989D ${formatYuan(spendable)} \u4F4E\u4E8E\u9608\u503C ${formatYuan(threshold)}\uFF0C\u5DF2\u963B\u6B62\u521B\u5EFA\u5B9E\u4F8B`,
+      {
+        code: "INSUFFICIENT_BALANCE",
+        hint: "\u5148\u5145\u503C\uFF0C\u6216\u7528 --min-balance 0 \u663E\u5F0F\u8DF3\u8FC7\u8FD9\u9053\u95F8\u95E8\u3002",
+        details: { spendableYuan: spendable, thresholdYuan: threshold }
+      }
+    );
+  }
+  return spendable;
+}
+
+// src/guard/idle.ts
+var QUERY = "nvidia-smi --query-gpu=utilization.gpu --format=csv,noheader,nounits";
+function parseUtilisation(stdout) {
+  const values = stdout.split("\n").map((line) => line.trim()).filter(Boolean).map(Number).filter((n) => !Number.isNaN(n));
+  if (values.length === 0) return null;
+  return values.reduce((sum, v) => sum + v, 0) / values.length;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      { once: true }
+    );
+  });
+}
+async function watchIdle(client, uuid, options = {}) {
+  const threshold = options.thresholdPercent ?? 5;
+  const required = options.samples ?? 6;
+  const intervalSeconds = options.intervalSeconds ?? 60;
+  let consecutive = 0;
+  let taken = 0;
+  let last = null;
+  note(
+    `\u95F2\u7F6E\u68C0\u6D4B\u5DF2\u542F\u52A8\uFF1AGPU \u5229\u7528\u7387 \u2264 ${threshold}% \u8FDE\u7EED ${required} \u6B21\uFF08\u6BCF ${formatDuration(intervalSeconds)} \u4E00\u6B21\uFF09\u540E\u81EA\u52A8\u5173\u673A`
+  );
+  while (!options.signal?.aborted) {
+    let utilisation = null;
+    try {
+      const result = await execCommand(client, uuid, QUERY, { capture: true, timeoutMs: 6e4 });
+      utilisation = parseUtilisation(result.stdout);
+    } catch (err) {
+      debug(`\u91C7\u6837\u5931\u8D25\uFF0C\u8DF3\u8FC7\u672C\u6B21\uFF1A${err.message}`);
+      await sleep(intervalSeconds * 1e3, options.signal);
+      continue;
+    }
+    taken++;
+    if (utilisation === null) {
+      warn("nvidia-smi \u672A\u8FD4\u56DE\u53EF\u7528\u6570\u636E\uFF0C\u8DF3\u8FC7\u672C\u6B21\u91C7\u6837");
+      await sleep(intervalSeconds * 1e3, options.signal);
+      continue;
+    }
+    last = utilisation;
+    consecutive = utilisation <= threshold ? consecutive + 1 : 0;
+    options.onSample?.(utilisation, consecutive);
+    debug(`GPU \u5229\u7528\u7387 ${utilisation.toFixed(1)}%\uFF08\u8FDE\u7EED\u95F2\u7F6E ${consecutive}/${required}\uFF09`);
+    if (consecutive >= required) {
+      if (options.dryRun) {
+        note("dry-run\uFF1A\u672C\u5E94\u5728\u6B64\u5173\u673A");
+        return { stopped: false, samplesTaken: taken, lastUtilisation: last, reason: "dry-run" };
+      }
+      await powerOffInstance(client, uuid);
+      return { stopped: true, samplesTaken: taken, lastUtilisation: last, reason: "idle" };
+    }
+    await sleep(intervalSeconds * 1e3, options.signal);
+  }
+  return { stopped: false, samplesTaken: taken, lastUtilisation: last, reason: "aborted" };
+}
+
+// src/ssh/transfer.ts
+import { createReadStream, createWriteStream } from "fs";
+import { mkdir, readdir, readFile, stat } from "fs/promises";
+import { basename, dirname, join, posix, relative, resolve as resolvePath, sep } from "path";
+import { pipeline } from "stream/promises";
+var ALWAYS_IGNORE = [
+  ".git",
+  "node_modules",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".mypy_cache",
+  ".pytest_cache",
+  ".DS_Store",
+  "*.pyc"
+];
+function sftp(conn) {
+  return new Promise((resolve, reject) => {
+    conn.sftp((err, handle) => {
+      if (err) reject(new SSHError(`SFTP \u901A\u9053\u5EFA\u7ACB\u5931\u8D25\uFF1A${err.message}`, { cause: err }));
+      else resolve(handle);
+    });
+  });
+}
+function toMatcher(pattern) {
+  const trimmed = pattern.trim();
+  const anchored = trimmed.startsWith("/");
+  const body = (anchored ? trimmed.slice(1) : trimmed).replace(/\/$/, "");
+  const escaped = body.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
+  const regex = new RegExp(anchored ? `^${escaped}(/|$)` : `(^|/)${escaped}(/|$)`);
+  return (relPath) => regex.test(relPath);
+}
+async function loadIgnoreFile(root, name) {
+  try {
+    const content = await readFile(join(root, name), "utf8");
+    return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#") && !line.startsWith("!"));
+  } catch {
+    return [];
+  }
+}
+async function buildIgnoreMatcher(root, options) {
+  const patterns = [...ALWAYS_IGNORE, ...options.ignore ?? []];
+  if (!options.noIgnoreFiles) {
+    const fromAutodl = await loadIgnoreFile(root, ".autodlignore");
+    patterns.push(...fromAutodl.length ? fromAutodl : await loadIgnoreFile(root, ".gitignore"));
+  }
+  const matchers = patterns.map(toMatcher);
+  return (relPath) => matchers.some((match) => match(relPath));
+}
+async function collectFiles(root, ignored) {
+  const files = [];
+  async function walk(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolute = join(dir, entry.name);
+      const rel = relative(root, absolute).split(sep).join("/");
+      if (ignored(rel)) {
+        debug(`\u8DF3\u8FC7 ${rel}`);
+        continue;
+      }
+      if (entry.isDirectory()) await walk(absolute);
+      else if (entry.isFile()) files.push(rel);
+    }
+  }
+  await walk(root);
+  return files;
+}
+function mkdirRemote(handle, path) {
+  return new Promise((resolve) => {
+    handle.mkdir(path, () => resolve());
+  });
+}
+async function ensureRemoteDir(handle, path) {
+  const segments = path.split("/").filter(Boolean);
+  let current = path.startsWith("/") ? "" : ".";
+  for (const segment of segments) {
+    current = `${current}/${segment}`;
+    await mkdirRemote(handle, current);
+  }
+}
+function uploadFile(handle, local, remote) {
+  return pipeline(createReadStream(local), handle.createWriteStream(remote));
+}
+function downloadFile(handle, remote, local) {
+  return pipeline(handle.createReadStream(remote), createWriteStream(local));
+}
+function statRemote(handle, path) {
+  return new Promise((resolve, reject) => {
+    handle.stat(path, (err, stats) => {
+      if (err) reject(new AutoDLError(`\u8FDC\u7A0B\u8DEF\u5F84\u4E0D\u53EF\u8BBF\u95EE\uFF1A${path}`, { cause: err }));
+      else resolve({ isDirectory: stats.isDirectory(), size: stats.size });
+    });
+  });
+}
+function readdirRemote(handle, path) {
+  return new Promise((resolve, reject) => {
+    handle.readdir(path, (err, list) => {
+      if (err) reject(new AutoDLError(`\u65E0\u6CD5\u5217\u51FA\u8FDC\u7A0B\u76EE\u5F55\uFF1A${path}`, { cause: err }));
+      else
+        resolve(
+          list.map((item) => ({
+            name: item.filename,
+            isDirectory: (item.attrs.mode & 61440) === 16384
+          }))
+        );
+    });
+  });
+}
+async function push(client, uuid, localPath, remotePath, options = {}) {
+  const local = resolvePath(localPath);
+  const info = await stat(local).catch(() => null);
+  if (!info) throw new AutoDLError(`\u672C\u5730\u8DEF\u5F84\u4E0D\u5B58\u5728\uFF1A${localPath}`);
+  return withSSH(
+    client,
+    uuid,
+    async (conn) => {
+      const handle = await sftp(conn);
+      try {
+        if (info.isFile()) {
+          const target = remotePath.endsWith("/") ? posix.join(remotePath, basename(local)) : remotePath;
+          await ensureRemoteDir(handle, posix.dirname(target));
+          await uploadFile(handle, local, target);
+          options.onProgress?.({ file: basename(local), index: 1, total: 1, bytes: info.size });
+          return { files: 1, bytes: info.size };
+        }
+        const ignored = await buildIgnoreMatcher(local, options);
+        const files = await collectFiles(local, ignored);
+        await ensureRemoteDir(handle, remotePath);
+        let bytes = 0;
+        const dirs = new Set(files.map((f) => posix.dirname(f)).filter((d) => d !== "."));
+        for (const dir of [...dirs].sort()) {
+          await ensureRemoteDir(handle, posix.join(remotePath, dir));
+        }
+        for (const [index, rel] of files.entries()) {
+          const source = join(local, rel);
+          const size = (await stat(source)).size;
+          await uploadFile(handle, source, posix.join(remotePath, rel));
+          bytes += size;
+          options.onProgress?.({ file: rel, index: index + 1, total: files.length, bytes: size });
+        }
+        return { files: files.length, bytes };
+      } finally {
+        handle.end();
+      }
+    },
+    options
+  );
+}
+async function pull(client, uuid, remotePath, localPath, options = {}) {
+  const local = resolvePath(localPath);
+  return withSSH(
+    client,
+    uuid,
+    async (conn) => {
+      const handle = await sftp(conn);
+      try {
+        const info = await statRemote(handle, remotePath);
+        if (!info.isDirectory) {
+          const target = local.endsWith(sep) ? join(local, basename(remotePath)) : local;
+          await mkdir(dirname(target), { recursive: true });
+          await downloadFile(handle, remotePath, target);
+          options.onProgress?.({
+            file: basename(remotePath),
+            index: 1,
+            total: 1,
+            bytes: info.size
+          });
+          return { files: 1, bytes: info.size };
+        }
+        const collected = [];
+        const walk = async (dir, prefix) => {
+          for (const entry of await readdirRemote(handle, dir)) {
+            const remote = posix.join(dir, entry.name);
+            const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+            if (entry.isDirectory) await walk(remote, rel);
+            else collected.push({ remote, rel, size: (await statRemote(handle, remote)).size });
+          }
+        };
+        await walk(remotePath, "");
+        let bytes = 0;
+        for (const [index, item] of collected.entries()) {
+          const target = join(local, item.rel);
+          await mkdir(dirname(target), { recursive: true });
+          await downloadFile(handle, item.remote, target);
+          bytes += item.size;
+          options.onProgress?.({
+            file: item.rel,
+            index: index + 1,
+            total: collected.length,
+            bytes: item.size
+          });
+        }
+        return { files: collected.length, bytes };
+      } finally {
+        handle.end();
+      }
+    },
+    options
+  );
+}
+
+// src/workflow/deploy.ts
+var DATA_DISK = "/root/autodl-tmp";
+var ALIVE_MARKER = "AUTODL_START_OK";
+var DEAD_MARKER = "AUTODL_START_DEAD";
+var SETUP_RECIPES = [
+  { file: "environment.yml", command: "conda env update -f environment.yml --prune" },
+  { file: "requirements.txt", command: "pip install -r requirements.txt" },
+  { file: "pyproject.toml", command: "pip install -e ." },
+  { file: "package-lock.json", command: "npm ci" },
+  { file: "package.json", command: "npm install" }
+];
+function quote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function withAcceleration(command, enabled) {
+  return enabled ? `source /etc/network_turbo >/dev/null 2>&1; ${command}` : command;
+}
+async function run(client, uuid, command, options, { label, capture = true }) {
+  debug(`[${label}] ${redactCredentials(command)}`);
+  const result = await execCommand(client, uuid, command, {
+    capture,
+    stdout: isJson() ? process.stderr : process.stdout,
+    stderr: process.stderr,
+    ...options.commandTimeoutMs !== void 0 ? { timeoutMs: options.commandTimeoutMs } : {},
+    ...options.signal ? { signal: options.signal } : {}
+  });
+  return result;
+}
+async function detectSetup(client, uuid, dir, options) {
+  const probe = SETUP_RECIPES.map(
+    (recipe2) => `[ -f ${quote(`${dir}/${recipe2.file}`)} ] && echo ${quote(recipe2.file)}`
+  ).join("; ");
+  const result = await run(client, uuid, `${probe}; true`, options, {
+    label: "detect",
+    capture: true
+  });
+  const present = new Set(
+    result.stdout.split("\n").map((line) => line.trim()).filter(Boolean)
+  );
+  const recipe = SETUP_RECIPES.find((candidate) => present.has(candidate.file));
+  if (!recipe) {
+    note(
+      "\u672A\u63A2\u6D4B\u5230\u4F9D\u8D56\u6E05\u5355\uFF08environment.yml / requirements.txt / pyproject.toml / package.json\uFF09\uFF0C\u8DF3\u8FC7\u5B89\u88C5"
+    );
+    return null;
+  }
+  note(`\u63A2\u6D4B\u5230 ${recipe.file}\uFF0C\u5C06\u6267\u884C\uFF1A${recipe.command}`);
+  return recipe.command;
+}
+async function checkout(client, uuid, repo, dir, options) {
+  const accelerate = repo.needsAcceleration && !options.noAcceleration;
+  if (accelerate) note("\u5DF2\u542F\u7528\u5B66\u672F\u8D44\u6E90\u52A0\u901F\uFF08\u4EC5\u8986\u76D6 GitHub / HuggingFace\uFF09");
+  const { url } = withCredentials(repo, options.gitToken);
+  const branch = options.branch;
+  const update = [
+    `cd ${quote(dir)}`,
+    `git remote set-url origin ${quote(url)}`,
+    "git fetch --depth 1 origin",
+    branch ? `git checkout -B ${quote(branch)} origin/${quote(branch)}` : "git reset --hard @{u}"
+  ].join(" && ");
+  const clone = [
+    `mkdir -p ${quote(DATA_DISK)}`,
+    `git clone --depth 1 ${branch ? `--branch ${quote(branch)} ` : ""}${quote(url)} ${quote(dir)}`
+  ].join(" && ");
+  const scrub = `cd ${quote(dir)} && git remote set-url origin ${quote(repo.cloneUrl)}`;
+  const command = withAcceleration(
+    `if [ -d ${quote(`${dir}/.git`)} ]; then ${update}; else ${clone}; fi && ${scrub}`,
+    accelerate
+  );
+  const result = await run(client, uuid, command, options, { label: "checkout", capture: true });
+  if (result.exitCode !== 0) {
+    throw new UsageError(`\u62C9\u53D6\u4ED3\u5E93\u5931\u8D25\uFF08\u9000\u51FA\u7801 ${result.exitCode}\uFF09`, {
+      hint: options.gitToken ? "\u786E\u8BA4 token \u5BF9\u8BE5\u4ED3\u5E93\u6709\u8BFB\u6743\u9650\u3002" : "\u79C1\u6709\u4ED3\u5E93\u9700\u8981 --git-token\uFF0C\u6216\u8BBE\u7F6E GIT_TOKEN / GITHUB_TOKEN \u73AF\u5883\u53D8\u91CF\u3002",
+      details: { stderr: redactCredentials(result.stderr).slice(0, 500) }
+    });
+  }
+  success(`\u4EE3\u7801\u5DF2\u5C31\u7EEA\uFF1A${dir}`);
+}
+async function describeAccess(client, uuid, dir, detached) {
+  if (!detached) return { publicUrls: [], tunnelHint: null, logHint: null };
+  const logHint = `autodl exec ${uuid} "tail -f ${dir}/.autodl/start.log"`;
+  try {
+    const snapshot = await getInstanceSnapshot(client, uuid);
+    const publicUrls = snapshot.services.map(
+      (service) => `${service.protocol === "http" ? "https://" : ""}${service.domain} (:${service.port})`
+    );
+    return {
+      publicUrls,
+      // 6006/6008 public mapping needs enterprise verification; personal accounts tunnel.
+      tunnelHint: publicUrls.length ? null : `autodl ssh ${uuid} -L 6006:localhost:6006`,
+      logHint
+    };
+  } catch {
+    return { publicUrls: [], tunnelHint: `autodl ssh ${uuid} -L 6006:localhost:6006`, logHint };
+  }
+}
+async function deployWorkflow(client, options) {
+  const startedAt = Date.now();
+  const repo = parseRepo(options.repo);
+  const dir = options.dir ?? `${DATA_DISK}/${repo.name}`;
+  const onFinish = options.onFinish ?? "poweroff";
+  let uuid = options.instanceUuid;
+  let created = false;
+  if (uuid) {
+    const status = await getInstanceStatus(client, uuid);
+    if (status !== "running") {
+      note(t("instance.poweringOn"));
+      await powerOnInstance(client, uuid, {
+        startCommand: composeStartCommand(options.ttlSeconds, void 0)
+      });
+      await waitForRunning(client, uuid, {
+        ...options.signal ? { signal: options.signal } : {}
+      });
+    }
+    const armed = await armTTLOverSSH(client, uuid, options.ttlSeconds);
+    if (!armed) warn(t("guard.armFailed"));
+    recordTTL({ uuid, ttlSeconds: options.ttlSeconds, inInstanceTimer: armed });
+    success(`\u590D\u7528\u5B9E\u4F8B ${uuid}`);
+  } else {
+    if (!options.gpu) {
+      throw new UsageError("\u5FC5\u987B\u6307\u5B9A --gpu\uFF08\u6216\u7528 --instance \u590D\u7528\u5DF2\u6709\u5B9E\u4F8B\uFF09", {
+        hint: "\u8FD0\u884C `autodl gpus` \u67E5\u770B\u89C4\u683C\uFF0C`autodl stock` \u67E5\u770B\u54EA\u91CC\u6709\u8D27\u3002"
+      });
+    }
+    const spec = resolveGpuSpec(options.gpu);
+    if (!spec) {
+      throw new UsageError(`\u672A\u77E5\u7684 GPU \u89C4\u683C "${options.gpu}"`, {
+        hint: "\u8FD0\u884C `autodl gpus` \u67E5\u770B\u5B98\u65B9 API \u652F\u6301\u7684\u5168\u90E8\u89C4\u683C\u3002"
+      });
+    }
+    const imageInput = options.image ?? DEFAULT_BASE_IMAGE;
+    const image = findBaseImage(imageInput);
+    const imageUuid = image?.uuid ?? imageInput;
+    const requestedRegions = (options.regions ?? []).map(
+      (input) => assertProCreateRegion(input).id
+    );
+    await assertBudget(client, options.minBalanceYuan);
+    const regions = options.stockCheck === false ? requestedRegions : (await chooseRegions(client, spec, requestedRegions)).regions;
+    note(t("instance.creating"));
+    uuid = await createInstance(client, {
+      gpuSpec: spec.id,
+      gpuNum: options.gpuNum ?? 1,
+      imageUuid,
+      cudaFrom: parseCudaVersion(image?.cuda ?? "11.8"),
+      expandSystemDiskGb: options.diskGb ?? 0,
+      ...regions.length ? { regions } : {},
+      name: options.name ?? repo.name,
+      ...composeStartCommand(options.ttlSeconds, void 0) ? { startCommand: composeStartCommand(options.ttlSeconds, void 0) } : {}
+    });
+    created = true;
+    recordTTL({
+      uuid,
+      name: options.name ?? repo.name,
+      ttlSeconds: options.ttlSeconds,
+      inInstanceTimer: true
+    });
+    success(`${t("instance.created")}\uFF1A${uuid}\uFF08TTL ${formatDuration(options.ttlSeconds)}\uFF09`);
+    note(t("instance.waiting"));
+    await waitForRunning(client, uuid, { ...options.signal ? { signal: options.signal } : {} });
+    success(t("instance.ready"));
+  }
+  const instanceUuid = uuid;
+  let setupCommand = null;
+  let startCommand = null;
+  let exitCode = null;
+  let stdout = "";
+  let stderr = "";
+  let access = { publicUrls: [], tunnelHint: null, logHint: null };
+  try {
+    await checkout(client, instanceUuid, repo, dir, options);
+    if (!options.noSetup) {
+      setupCommand = options.setup ?? await detectSetup(client, instanceUuid, dir, options);
+      if (setupCommand) {
+        note("\u6B63\u5728\u5B89\u88C5\u4F9D\u8D56\u2026");
+        const accelerate = repo.needsAcceleration && !options.noAcceleration;
+        const result = await run(
+          client,
+          instanceUuid,
+          withAcceleration(`cd ${quote(dir)} && ${setupCommand}`, accelerate),
+          options,
+          { label: "setup", capture: true }
+        );
+        if (result.exitCode !== 0) {
+          throw new UsageError(`\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25\uFF08\u9000\u51FA\u7801 ${result.exitCode}\uFF09`, {
+            hint: "\u53EF\u4EE5\u7528 --setup \u6307\u5B9A\u81EA\u5B9A\u4E49\u5B89\u88C5\u547D\u4EE4\uFF0C\u6216 --no-setup \u8DF3\u8FC7\u540E\u624B\u52A8\u5904\u7406\u3002"
+          });
+        }
+        success("\u4F9D\u8D56\u5B89\u88C5\u5B8C\u6210");
+      }
+    }
+    if (options.start) {
+      startCommand = options.start;
+      if (options.detach) {
+        const detached = [
+          `cd ${quote(dir)}`,
+          "mkdir -p .autodl",
+          `{ nohup ${options.start} > .autodl/start.log 2>&1 < /dev/null & echo $! > .autodl/start.pid; }`,
+          "sleep 2",
+          `if kill -0 "$(cat .autodl/start.pid)" 2>/dev/null; then echo "${ALIVE_MARKER} $(cat .autodl/start.pid)"; else echo "${DEAD_MARKER}"; tail -50 .autodl/start.log; exit 1; fi`
+        ].join(" && ");
+        const result = await run(client, instanceUuid, detached, options, {
+          label: "start",
+          capture: true
+        });
+        exitCode = result.exitCode;
+        stdout = result.stdout;
+        stderr = result.stderr;
+        if (result.exitCode !== 0 || result.stdout.includes(DEAD_MARKER)) {
+          throw new UsageError("\u540E\u53F0\u542F\u52A8\u5931\u8D25\uFF1A\u8FDB\u7A0B\u5DF2\u9000\u51FA", {
+            hint: `\u5B8C\u6574\u65E5\u5FD7\u5728\u5B9E\u4F8B\u4E0A\u7684 ${dir}/.autodl/start.log`,
+            details: {
+              log: result.stdout.replace(DEAD_MARKER, "").trim().slice(0, 800),
+              stderr: result.stderr.slice(0, 400)
+            }
+          });
+        }
+        success("\u5DF2\u5728\u540E\u53F0\u542F\u52A8\u5E76\u786E\u8BA4\u8FDB\u7A0B\u5B58\u6D3B");
+      } else {
+        note("\u6B63\u5728\u542F\u52A8\u9879\u76EE\u2026");
+        const result = await run(
+          client,
+          instanceUuid,
+          `cd ${quote(dir)} && ${options.start}`,
+          options,
+          { label: "start", capture: true }
+        );
+        exitCode = result.exitCode;
+        stdout = result.stdout;
+        stderr = result.stderr;
+      }
+    }
+    access = await describeAccess(
+      client,
+      instanceUuid,
+      dir,
+      Boolean(options.detach && options.start)
+    );
+  } finally {
+    await finish(client, instanceUuid, onFinish, Boolean(options.detach && options.start));
+  }
+  return {
+    instanceUuid,
+    created,
+    repo: { host: repo.host, path: repo.path, name: repo.name, branch: options.branch ?? null },
+    dir,
+    setupCommand,
+    startCommand,
+    detached: Boolean(options.detach && options.start),
+    exitCode,
+    stdout,
+    stderr,
+    access,
+    // A detached run deliberately leaves the instance up, so reporting the requested
+    // `poweroff` here would be a lie the caller might act on.
+    finalAction: options.detach && options.start ? "keep" : onFinish,
+    durationMs: Date.now() - startedAt
+  };
+}
+async function finish(client, uuid, action, detached) {
+  if (detached) {
+    warn(`\u5B9E\u4F8B ${uuid} \u4FDD\u6301\u8FD0\u884C\u4E2D\uFF08--detach\uFF09\uFF0C\u7528\u5B8C\u8BF7\u5173\u673A\uFF1Aautodl stop ${uuid}`);
+    return;
+  }
+  if (action === "keep") {
+    warn(`\u5B9E\u4F8B ${uuid} \u4ECD\u5728\u8FD0\u884C\uFF08--on-finish keep\uFF09\uFF0C\u8BB0\u5F97\u624B\u52A8\u5173\u673A\uFF1Aautodl stop ${uuid}`);
+    return;
+  }
+  note(t("run.cleanup"));
+  try {
+    const status = await getInstanceStatus(client, uuid).catch(() => "unknown");
+    if (status !== "shutdown" && status !== "shutting_down") {
+      await powerOffInstance(client, uuid);
+    }
+    success(`\u5B9E\u4F8B ${uuid} \u5DF2\u5173\u673A\uFF0C\u8BA1\u8D39\u5DF2\u505C\u6B62\uFF08\u6570\u636E\u4FDD\u7559\uFF0C\u53EF\u518D\u6B21\u90E8\u7F72\u590D\u7528\uFF09`);
+  } catch (err) {
+    warn(`\u81EA\u52A8\u5173\u673A\u5931\u8D25\uFF1A${err.message}`);
+    warn(`\u8BF7\u7ACB\u5373\u624B\u52A8\u5904\u7406\uFF1Aautodl stop ${uuid}`);
+    return;
+  }
+  if (action === "release") {
+    try {
+      await waitForShutdown(client, uuid, { timeoutMs: 10 * 6e4 });
+      await releaseInstance(client, uuid);
+      untrackInstance(uuid);
+      success(`\u5B9E\u4F8B ${uuid} \u5DF2\u91CA\u653E`);
+    } catch (err) {
+      warn(`\u91CA\u653E\u5931\u8D25\uFF08\u5B9E\u4F8B\u5DF2\u5173\u673A\uFF0C\u4E0D\u518D\u8BA1\u8D39\uFF09\uFF1A${err.message}`);
+      warn(`\u7A0D\u540E\u53EF\u91CD\u8BD5\uFF1Aautodl rm ${uuid} --yes`);
+    }
+  } else {
+    untrackInstance(uuid);
+  }
+}
+
+// src/workflow/run.ts
+import { mkdir as mkdir2 } from "fs/promises";
+var DEFAULT_WORKDIR = "/root/autodl-tmp/autodl-cli";
+async function runWorkflow(client, options) {
+  const startedAt = Date.now();
+  const spec = resolveGpuSpec(options.gpu);
+  if (!spec) {
+    throw new UsageError(`\u672A\u77E5\u7684 GPU \u89C4\u683C "${options.gpu}"`, {
+      hint: "\u8FD0\u884C `autodl gpus` \u67E5\u770B\u5B98\u65B9 API \u652F\u6301\u7684\u5168\u90E8\u89C4\u683C\u3002"
+    });
+  }
+  const imageInput = options.image ?? DEFAULT_BASE_IMAGE;
+  const image = findBaseImage(imageInput);
+  const imageUuid = image?.uuid ?? imageInput;
+  const cudaFrom = options.cudaFrom ? parseCudaVersion(options.cudaFrom) : parseCudaVersion(image?.cuda ?? "11.8");
+  const requestedRegions = (options.regions ?? []).map((input) => assertProCreateRegion(input).id);
+  const workdir = options.workdir ?? DEFAULT_WORKDIR;
+  const onFinish = options.onFinish ?? "poweroff";
+  await assertBudget(client, options.minBalanceYuan);
+  const regions = options.stockCheck === false ? requestedRegions : (await chooseRegions(client, spec, requestedRegions)).regions;
+  const startCommand = composeStartCommand(options.ttlSeconds, void 0);
+  note(t("instance.creating"));
+  const uuid = await createInstance(client, {
+    gpuSpec: spec.id,
+    gpuNum: options.gpuNum ?? 1,
+    imageUuid,
+    cudaFrom,
+    ...options.diskGb !== void 0 ? { expandSystemDiskGb: options.diskGb } : {},
+    ...regions.length ? { regions } : {},
+    ...options.name ? { name: options.name } : {},
+    ...startCommand ? { startCommand } : {}
+  });
+  recordTTL({
+    uuid,
+    ...options.name ? { name: options.name } : {},
+    ttlSeconds: options.ttlSeconds,
+    inInstanceTimer: true
+  });
+  success(`${t("instance.created")}\uFF1A${uuid}\uFF08TTL ${formatDuration(options.ttlSeconds)}\uFF09`);
+  let uploaded = null;
+  let downloaded = null;
+  let exitCode = null;
+  let stdout = "";
+  let stderr = "";
+  try {
+    note(t("instance.waiting"));
+    await waitForRunning(client, uuid, {
+      ...options.signal ? { signal: options.signal } : {},
+      onPoll: (status) => debug(`\u72B6\u6001\uFF1A${status}`)
+    });
+    success(t("instance.ready"));
+    if (options.sync) {
+      note(t("run.syncing"));
+      uploaded = await push(client, uuid, options.sync, workdir, {
+        ...options.signal ? { signal: options.signal } : {},
+        onProgress: ({ file, index, total }) => debug(`\u2191 [${index}/${total}] ${file}`)
+      });
+      success(`\u5DF2\u4E0A\u4F20 ${uploaded.files} \u4E2A\u6587\u4EF6\u5230 ${workdir}`);
+    }
+    note(t("run.executing"));
+    const result = await execCommand(client, uuid, options.command, {
+      capture: true,
+      // Same rule as `autodl exec`: stdout only when it isn't carrying the payload.
+      stdout: isJson() ? process.stderr : process.stdout,
+      stderr: process.stderr,
+      cwd: options.sync ? workdir : void 0,
+      ...options.env ? { env: options.env } : {},
+      ...options.commandTimeoutMs !== void 0 ? { timeoutMs: options.commandTimeoutMs } : {},
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    exitCode = result.exitCode;
+    stdout = result.stdout;
+    stderr = result.stderr;
+    if (options.pullFrom) {
+      const target = options.pullTo ?? "./autodl-output";
+      note(t("run.pulling"));
+      await mkdir2(target, { recursive: true });
+      downloaded = await pull(client, uuid, options.pullFrom, target, {
+        ...options.signal ? { signal: options.signal } : {},
+        onProgress: ({ file, index, total }) => debug(`\u2193 [${index}/${total}] ${file}`)
+      });
+      success(`\u5DF2\u56DE\u4F20 ${downloaded.files} \u4E2A\u6587\u4EF6\u5230 ${target}`);
+    }
+  } finally {
+    await finish2(client, uuid, onFinish);
+  }
+  return {
+    instanceUuid: uuid,
+    exitCode,
+    stdout,
+    stderr,
+    uploaded,
+    downloaded,
+    finalAction: onFinish,
+    durationMs: Date.now() - startedAt
+  };
+}
+async function finish2(client, uuid, action) {
+  if (action === "keep") {
+    warn(`\u5B9E\u4F8B ${uuid} \u4ECD\u5728\u8FD0\u884C\uFF08--on-finish keep\uFF09\uFF0C\u8BB0\u5F97\u624B\u52A8\u5173\u673A\uFF1Aautodl stop ${uuid}`);
+    return;
+  }
+  note(t("run.cleanup"));
+  try {
+    const status = await getInstanceStatus(client, uuid).catch(() => "unknown");
+    if (status !== "shutdown" && status !== "shutting_down") {
+      await powerOffInstance(client, uuid);
+    }
+    success(`\u5B9E\u4F8B ${uuid} \u5DF2\u5173\u673A\uFF0C\u8BA1\u8D39\u5DF2\u505C\u6B62`);
+  } catch (err) {
+    warn(`\u81EA\u52A8\u5173\u673A\u5931\u8D25\uFF1A${err.message}`);
+    warn(`\u8BF7\u7ACB\u5373\u624B\u52A8\u5904\u7406\uFF1Aautodl stop ${uuid}`);
+    return;
+  }
+  if (action === "release") {
+    try {
+      await waitForShutdown(client, uuid, { timeoutMs: 10 * 6e4 });
+      await releaseInstance(client, uuid);
+      untrackInstance(uuid);
+      success(`\u5B9E\u4F8B ${uuid} \u5DF2\u91CA\u653E`);
+    } catch (err) {
+      warn(`\u91CA\u653E\u5931\u8D25\uFF08\u5B9E\u4F8B\u5DF2\u5173\u673A\uFF0C\u4E0D\u518D\u8BA1\u8D39\uFF09\uFF1A${err.message}`);
+      warn(`\u7A0D\u540E\u53EF\u91CD\u8BD5\uFF1Aautodl rm ${uuid} --yes`);
+    }
+  } else {
+    untrackInstance(uuid);
+  }
+}
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+var DEFAULT_MCP_TTL = "2h";
+function ok(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function fail(err) {
+  const error = toAutoDLError(err);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ ok: false, error: error.toJSON() }, null, 2)
+      }
+    ],
+    isError: true
+  };
+}
+function tool(handler) {
+  return async (input) => {
+    try {
+      return ok({ ok: true, data: await handler(input) });
+    } catch (err) {
+      return fail(err);
+    }
+  };
+}
+function buildServer(context) {
+  const server = new McpServer(
+    { name: "autodl-cli", version: VERSION },
+    {
+      instructions: [
+        "\u901A\u8FC7 AutoDL \u5B98\u65B9\u5F00\u653E API \u7BA1\u7406 GPU \u5B9E\u4F8B\uFF1A\u521B\u5EFA\u3001\u5F00\u5173\u673A\u3001SSH \u6267\u884C\u547D\u4EE4\u3001\u4F20\u6587\u4EF6\u3002",
+        "\u91CD\u8981\uFF1AAutoDL \u6309\u5B9E\u4F8B\u5F00\u673A\u65F6\u957F\u8BA1\u8D39\uFF0C\u4E0E\u662F\u5426\u4F7F\u7528 GPU \u65E0\u5173\u3002\u7528\u5B8C\u8BF7\u7ACB\u523B\u8C03\u7528 autodl_power_off\u3002",
+        "\u521B\u5EFA\u5B9E\u4F8B\u9ED8\u8BA4\u5E26 2 \u5C0F\u65F6 TTL \u515C\u5E95\u81EA\u52A8\u5173\u673A\uFF1B\u5982\u679C\u4EFB\u52A1\u66F4\u957F\u8BF7\u663E\u5F0F\u4F20 ttl\u3002",
+        "\u5F00\u5173\u673A\u540E SSH \u7AEF\u53E3\u548C\u5BC6\u7801\u4F1A\u53D8\u5316\uFF0C\u4E0D\u8981\u7F13\u5B58 autodl_get_instance \u7684\u7ED3\u679C\u3002"
+      ].join("\n")
+    }
+  );
+  const { client } = context;
+  server.registerTool(
+    "autodl_account_info",
+    {
+      title: "\u67E5\u8BE2\u8D26\u53F7\u4F59\u989D",
+      description: "\u8FD4\u56DE AutoDL \u8D26\u53F7\u7684\u53EF\u7528\u4F59\u989D\u3001\u4EE3\u91D1\u5238\u4F59\u989D\u548C\u7D2F\u8BA1\u6D88\u8D39\uFF08\u5355\u4F4D\uFF1A\u5143\uFF09\u3002",
+      inputSchema: {},
+      annotations: { readOnlyHint: true }
+    },
+    tool(async () => {
+      const balance = await getBalance(client);
+      return { ...balance, spendableYuan: balance.balanceYuan + balance.voucherYuan };
+    })
+  );
+  server.registerTool(
+    "autodl_list_instances",
+    {
+      title: "\u5217\u51FA\u5B9E\u4F8B",
+      description: "\u5217\u51FA\u8D26\u53F7\u4E0B\u6240\u6709\u5B9E\u4F8B\u53CA\u5176\u72B6\u6001\u3002\u53EF\u7528 status \u8FC7\u6EE4\uFF0C\u5982 running / shutdown\u3002",
+      inputSchema: { status: z.string().optional().describe("\u6309\u72B6\u6001\u8FC7\u6EE4\uFF0C\u4F8B\u5982 running") },
+      annotations: { readOnlyHint: true }
+    },
+    tool(async ({ status }) => {
+      const instances = await listAllInstances(client);
+      return status ? instances.filter((i) => i.status === status) : instances;
+    })
+  );
+  server.registerTool(
+    "autodl_get_instance",
+    {
+      title: "\u67E5\u8BE2\u5B9E\u4F8B\u8BE6\u60C5",
+      description: "\u8FD4\u56DE\u5B9E\u4F8B\u8BE6\u60C5\u4E0E\u5B9E\u65F6 SSH \u8FDE\u63A5\u4FE1\u606F\u3002\u6CE8\u610F\uFF1A\u5B9E\u4F8B\u6BCF\u6B21\u5F00\u5173\u673A\u540E SSH \u7AEF\u53E3\u548C root \u5BC6\u7801\u90FD\u4F1A\u53D8\u5316\uFF0C\u52A1\u5FC5\u6BCF\u6B21\u91CD\u65B0\u8C03\u7528\u800C\u4E0D\u8981\u7F13\u5B58\u3002",
+      inputSchema: {
+        instance_uuid: z.string().describe("\u5B9E\u4F8B ID\uFF0C\u4F8B\u5982 pro-76419909953e"),
+        reveal_password: z.boolean().optional().describe("\u662F\u5426\u8FD4\u56DE root \u5BC6\u7801\u660E\u6587\uFF0C\u9ED8\u8BA4\u8131\u654F\u4E3A ***")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    tool(
+      async ({
+        instance_uuid,
+        reveal_password
+      }) => {
+        const instance = await findInstance(client, instance_uuid);
+        const snapshot = await getInstanceSnapshot(client, instance_uuid).catch(() => null);
+        return {
+          instance,
+          snapshot: snapshot ? reveal_password ? snapshot : redactSnapshot(snapshot) : null
+        };
+      }
+    )
+  );
+  server.registerTool(
+    "autodl_create_instance",
+    {
+      title: "\u521B\u5EFA GPU \u5B9E\u4F8B",
+      description: [
+        "\u521B\u5EFA\u4E00\u53F0\u6309\u91CF\u8BA1\u8D39\u7684 AutoDL Pro \u5B9E\u4F8B\u5E76\u53EF\u9009\u7B49\u5F85\u5176\u5C31\u7EEA\u3002",
+        "\u4F1A\u5148\u68C0\u67E5\u4F59\u989D\uFF1B\u4F59\u989D\u4E0D\u8DB3\u4F1A\u76F4\u63A5\u62D2\u7EDD\u3002",
+        "\u9ED8\u8BA4\u5E26 2 \u5C0F\u65F6 TTL \u515C\u5E95\u81EA\u52A8\u5173\u673A\u2014\u2014\u957F\u4EFB\u52A1\u8BF7\u663E\u5F0F\u52A0\u5927 ttl\uFF0C\u4E0D\u8981\u5173\u95ED\u5B83\u3002",
+        "\u5B98\u65B9 API \u6CA1\u6709\u5E93\u5B58\u67E5\u8BE2\u63A5\u53E3\uFF0C\u65E0\u8D27\u65F6\u4F1A\u8FD4\u56DE NO_STOCK\uFF0C\u6362 GPU \u89C4\u683C\u6216\u5730\u533A\u91CD\u8BD5\u5373\u53EF\u3002"
+      ].join("\n"),
+      inputSchema: {
+        gpu: z.string().describe("GPU \u89C4\u683C\uFF0C\u5982 4090 / pro6000-p\uFF0C\u7528 autodl_list_gpu_specs \u67E5\u770B"),
+        gpu_num: z.number().int().min(1).max(4).optional().describe("GPU \u6570\u91CF 1-4\uFF0C\u9ED8\u8BA4 1"),
+        image: z.string().optional().describe("\u955C\u50CF UUID\uFF0C\u9ED8\u8BA4 PyTorch 2.0 / CUDA 11.8"),
+        regions: z.array(z.string()).optional().describe("\u4F18\u5148\u5730\u533A\u4EE3\u7801\u5217\u8868"),
+        disk_gb: z.number().int().min(0).max(500).optional().describe("\u7CFB\u7EDF\u76D8\u6269\u5BB9 GB\uFF0C\u9ED8\u8BA4 0"),
+        name: z.string().optional().describe("\u5B9E\u4F8B\u540D\u79F0"),
+        ttl: z.string().optional().describe("\u5230\u671F\u81EA\u52A8\u5173\u673A\u65F6\u957F\uFF0C\u5982 2h / 90m\uFF0C\u9ED8\u8BA4 2h"),
+        wait: z.boolean().optional().describe("\u662F\u5426\u7B49\u5F85\u5B9E\u4F8B\u8FDB\u5165 running\uFF0C\u9ED8\u8BA4 true")
+      },
+      annotations: { destructiveHint: false, idempotentHint: false }
+    },
+    tool(
+      async (input) => {
+        const spec = resolveGpuSpec(input.gpu);
+        if (!spec) {
+          throw new UsageError(`\u672A\u77E5\u7684 GPU \u89C4\u683C "${input.gpu}"`, {
+            hint: "\u8C03\u7528 autodl_list_gpu_specs \u67E5\u770B\u5168\u90E8\u53EF\u7528\u89C4\u683C\u3002"
+          });
+        }
+        const image = findBaseImage(input.image ?? DEFAULT_BASE_IMAGE);
+        const imageUuid = image?.uuid ?? input.image ?? DEFAULT_BASE_IMAGE;
+        const regions = (input.regions ?? []).map((value) => {
+          const region = resolveRegion(value);
+          if (!region) throw new UsageError(`\u672A\u77E5\u7684\u5730\u533A "${value}"`);
+          return region.id;
+        });
+        const ttlSeconds = parseDuration(input.ttl ?? DEFAULT_MCP_TTL);
+        await assertBudget(client);
+        const startCommand = composeStartCommand(ttlSeconds, void 0);
+        const uuid = await createInstance(client, {
+          gpuSpec: spec.id,
+          gpuNum: input.gpu_num ?? 1,
+          imageUuid,
+          cudaFrom: parseCudaVersion(image?.cuda ?? "11.8"),
+          expandSystemDiskGb: input.disk_gb ?? 0,
+          ...regions.length ? { regions } : {},
+          ...input.name ? { name: input.name } : {},
+          ...startCommand ? { startCommand } : {}
+        });
+        recordTTL({
+          uuid,
+          ...input.name ? { name: input.name } : {},
+          ttlSeconds,
+          inInstanceTimer: true
+        });
+        let status = "creating";
+        if (input.wait !== false) status = await waitForRunning(client, uuid);
+        return {
+          instance_uuid: uuid,
+          status,
+          gpu_spec: spec.id,
+          gpu_num: input.gpu_num ?? 1,
+          image_uuid: imageUuid,
+          ttl_seconds: ttlSeconds,
+          note: `\u5B9E\u4F8B\u5C06\u5728 ${input.ttl ?? DEFAULT_MCP_TTL} \u540E\u81EA\u52A8\u5173\u673A\u3002\u7528\u5B8C\u8BF7\u5C3D\u5FEB\u8C03\u7528 autodl_power_off \u505C\u6B62\u8BA1\u8D39\u3002`
+        };
+      }
+    )
+  );
+  server.registerTool(
+    "autodl_power_on",
+    {
+      title: "\u5F00\u673A",
+      description: "\u542F\u52A8\u4E00\u53F0\u5DF2\u5173\u673A\u7684\u5B9E\u4F8B\uFF0C\u5E76\u53EF\u9009\u7B49\u5F85\u5176\u5C31\u7EEA\u3002\u5F00\u673A\u540E SSH \u7AEF\u53E3\u548C\u5BC6\u7801\u4F1A\u53D8\u5316\u3002",
+      inputSchema: {
+        instance_uuid: z.string(),
+        ttl: z.string().optional().describe("\u5F00\u673A\u540E\u8BBE\u7F6E\u7684\u81EA\u52A8\u5173\u673A\u65F6\u957F\uFF0C\u9ED8\u8BA4 2h"),
+        wait: z.boolean().optional().describe("\u662F\u5426\u7B49\u5F85 running\uFF0C\u9ED8\u8BA4 true")
+      }
+    },
+    tool(async (input) => {
+      const ttlSeconds = parseDuration(input.ttl ?? DEFAULT_MCP_TTL);
+      await powerOnInstance(client, input.instance_uuid, {
+        startCommand: composeStartCommand(ttlSeconds, void 0)
+      });
+      let status = "starting";
+      let armed = false;
+      if (input.wait !== false) {
+        status = await waitForRunning(client, input.instance_uuid);
+        armed = await armTTLOverSSH(client, input.instance_uuid, ttlSeconds);
+        recordTTL({ uuid: input.instance_uuid, ttlSeconds, inInstanceTimer: armed });
+      }
+      return {
+        instance_uuid: input.instance_uuid,
+        status,
+        ttl_seconds: ttlSeconds,
+        ttl_armed: armed
+      };
+    })
+  );
+  server.registerTool(
+    "autodl_power_off",
+    {
+      title: "\u5173\u673A",
+      description: "\u5173\u95ED\u5B9E\u4F8B\uFF0C\u7ACB\u5373\u505C\u6B62\u8BA1\u8D39\u3002\u6570\u636E\u5168\u90E8\u4FDD\u7559\uFF0C\u968F\u65F6\u53EF\u4EE5\u518D\u6B21\u5F00\u673A\u3002",
+      inputSchema: { instance_uuid: z.string() }
+    },
+    tool(async ({ instance_uuid }) => {
+      await powerOffInstance(client, instance_uuid);
+      untrackInstance(instance_uuid);
+      return { instance_uuid, stopped: true };
+    })
+  );
+  server.registerTool(
+    "autodl_release_instance",
+    {
+      title: "\u91CA\u653E\u5B9E\u4F8B\uFF08\u4E0D\u53EF\u9006\uFF09",
+      description: "\u6C38\u4E45\u91CA\u653E\u5B9E\u4F8B\uFF0C\u6240\u6709\u6570\u636E\u4F1A\u88AB\u6E05\u7A7A\u4E14\u65E0\u6CD5\u6062\u590D\u3002\u5FC5\u987B\u5148\u5173\u673A\u3002\u9700\u8981\u663E\u5F0F\u4F20 confirm=true \u624D\u4F1A\u6267\u884C\u3002",
+      inputSchema: {
+        instance_uuid: z.string(),
+        confirm: z.boolean().describe("\u5FC5\u987B\u663E\u5F0F\u4F20 true\uFF0C\u786E\u8BA4\u7406\u89E3\u6570\u636E\u5C06\u88AB\u6C38\u4E45\u6E05\u7A7A")
+      },
+      annotations: { destructiveHint: true, idempotentHint: false }
+    },
+    tool(async ({ instance_uuid, confirm }) => {
+      if (confirm !== true) {
+        throw new UsageError("\u91CA\u653E\u5B9E\u4F8B\u662F\u4E0D\u53EF\u9006\u64CD\u4F5C\uFF0C\u5FC5\u987B\u663E\u5F0F\u4F20 confirm=true", {
+          hint: "\u786E\u8BA4\u8981\u6C38\u4E45\u5220\u9664\u8BE5\u5B9E\u4F8B\u7684\u5168\u90E8\u6570\u636E\u540E\uFF0C\u518D\u5E26 confirm: true \u91CD\u65B0\u8C03\u7528\u3002"
+        });
+      }
+      const status = await getInstanceStatus(client, instance_uuid);
+      if (status !== "shutdown") {
+        await powerOffInstance(client, instance_uuid);
+      }
+      await releaseInstance(client, instance_uuid);
+      untrackInstance(instance_uuid);
+      return { instance_uuid, released: true };
+    })
+  );
+  server.registerTool(
+    "autodl_exec",
+    {
+      title: "\u5728\u5B9E\u4F8B\u4E0A\u6267\u884C\u547D\u4EE4",
+      description: "\u901A\u8FC7 SSH \u5728\u5B9E\u4F8B\u4E0A\u6267\u884C shell \u547D\u4EE4\uFF0C\u8FD4\u56DE stdout / stderr / \u9000\u51FA\u7801\u3002\u6BCF\u6B21\u90FD\u4F1A\u91CD\u65B0\u83B7\u53D6 SSH \u51ED\u8BC1\uFF0C\u56E0\u6B64\u5B9E\u4F8B\u91CD\u542F\u540E\u4F9D\u7136\u53EF\u7528\u3002",
+      inputSchema: {
+        instance_uuid: z.string(),
+        command: z.string().describe("\u8981\u6267\u884C\u7684 shell \u547D\u4EE4"),
+        cwd: z.string().optional().describe("\u8FDC\u7A0B\u5DE5\u4F5C\u76EE\u5F55"),
+        timeout: z.string().optional().describe("\u8D85\u65F6\u65F6\u95F4\uFF0C\u5982 30m\uFF0C\u9ED8\u8BA4 30m"),
+        start_if_stopped: z.boolean().optional().describe("\u5B9E\u4F8B\u672A\u8FD0\u884C\u65F6\u662F\u5426\u81EA\u52A8\u5F00\u673A\uFF0C\u9ED8\u8BA4 false")
+      }
+    },
+    tool(
+      async (input) => {
+        const result = await execCommand(client, input.instance_uuid, input.command, {
+          capture: true,
+          autoStart: input.start_if_stopped ?? false,
+          timeoutMs: parseDuration(input.timeout ?? "30m") * 1e3,
+          ...input.cwd ? { cwd: input.cwd } : {}
+        });
+        return {
+          instance_uuid: input.instance_uuid,
+          exit_code: result.exitCode,
+          signal: result.signal,
+          stdout: result.stdout,
+          stderr: result.stderr
+        };
+      }
+    )
+  );
+  server.registerTool(
+    "autodl_upload",
+    {
+      title: "\u4E0A\u4F20\u6587\u4EF6\u5230\u5B9E\u4F8B",
+      description: "\u901A\u8FC7 SFTP \u4E0A\u4F20\u672C\u5730\u6587\u4EF6\u6216\u76EE\u5F55\u5230\u5B9E\u4F8B\u3002\u76EE\u5F55\u4F1A\u81EA\u52A8\u8DF3\u8FC7 .git / node_modules \u7B49\u3002",
+      inputSchema: {
+        instance_uuid: z.string(),
+        local_path: z.string().describe("\u672C\u5730\u6587\u4EF6\u6216\u76EE\u5F55\u8DEF\u5F84"),
+        remote_path: z.string().optional().describe("\u8FDC\u7A0B\u76EE\u6807\u8DEF\u5F84\uFF0C\u9ED8\u8BA4 /root/autodl-tmp/autodl-cli\uFF08\u6570\u636E\u76D8\uFF09")
+      }
+    },
+    tool(async (input) => {
+      const remote = input.remote_path ?? "/root/autodl-tmp/autodl-cli";
+      const summary = await push(client, input.instance_uuid, input.local_path, remote);
+      return { instance_uuid: input.instance_uuid, remote_path: remote, ...summary };
+    })
+  );
+  server.registerTool(
+    "autodl_download",
+    {
+      title: "\u4ECE\u5B9E\u4F8B\u4E0B\u8F7D\u6587\u4EF6",
+      description: "\u901A\u8FC7 SFTP \u628A\u5B9E\u4F8B\u4E0A\u7684\u6587\u4EF6\u6216\u76EE\u5F55\u4E0B\u8F7D\u5230\u672C\u5730\u3002",
+      inputSchema: {
+        instance_uuid: z.string(),
+        remote_path: z.string(),
+        local_path: z.string().optional().describe("\u672C\u5730\u76EE\u6807\u76EE\u5F55\uFF0C\u9ED8\u8BA4 ./autodl-output")
+      }
+    },
+    tool(async (input) => {
+      const local = input.local_path ?? "./autodl-output";
+      const summary = await pull(client, input.instance_uuid, input.remote_path, local);
+      return { instance_uuid: input.instance_uuid, local_path: local, ...summary };
+    })
+  );
+  server.registerTool(
+    "autodl_run",
+    {
+      title: "\u4E00\u952E\u8DD1\u4EFB\u52A1",
+      description: [
+        "\u7AEF\u5230\u7AEF\u5DE5\u4F5C\u6D41\uFF1A\u521B\u5EFA\u5B9E\u4F8B \u2192 \u7B49\u5F85\u5C31\u7EEA \u2192 \u4E0A\u4F20\u4EE3\u7801 \u2192 \u8FDC\u7A0B\u6267\u884C \u2192 \u56DE\u4F20\u4EA7\u7269 \u2192 \u81EA\u52A8\u5173\u673A\u3002",
+        "\u9002\u5408\u201C\u8DD1\u4E00\u6B21\u5C31\u8D70\u201D\u7684\u4EFB\u52A1\uFF0C\u65E0\u9700\u81EA\u5DF1\u7F16\u6392\u751F\u547D\u5468\u671F\uFF0C\u4E5F\u4E0D\u4F1A\u5FD8\u8BB0\u5173\u673A\u3002",
+        "\u6CE8\u610F\uFF1A\u8FD9\u4E2A\u8C03\u7528\u4F1A\u963B\u585E\u5230\u4EFB\u52A1\u7ED3\u675F\uFF0C\u8BF7\u4E3A ttl \u548C timeout \u7559\u8DB3\u4F59\u91CF\u3002"
+      ].join("\n"),
+      inputSchema: {
+        command: z.string().describe("\u8981\u5728\u5B9E\u4F8B\u4E0A\u6267\u884C\u7684\u547D\u4EE4"),
+        gpu: z.string().describe("GPU \u89C4\u683C"),
+        gpu_num: z.number().int().min(1).max(4).optional(),
+        image: z.string().optional(),
+        regions: z.array(z.string()).optional(),
+        sync: z.string().optional().describe("\u6267\u884C\u524D\u4E0A\u4F20\u7684\u672C\u5730\u76EE\u5F55"),
+        workdir: z.string().optional().describe("\u8FDC\u7A0B\u5DE5\u4F5C\u76EE\u5F55\uFF0C\u9ED8\u8BA4 /root/autodl-tmp/autodl-cli\uFF08\u6570\u636E\u76D8\uFF09"),
+        pull_from: z.string().optional().describe("\u6267\u884C\u540E\u56DE\u4F20\u7684\u8FDC\u7A0B\u8DEF\u5F84"),
+        pull_to: z.string().optional().describe("\u56DE\u4F20\u4EA7\u7269\u7684\u672C\u5730\u76EE\u5F55"),
+        ttl: z.string().optional().describe("\u515C\u5E95\u81EA\u52A8\u5173\u673A\u65F6\u957F\uFF0C\u9ED8\u8BA4 4h"),
+        timeout: z.string().optional().describe("\u8FDC\u7A0B\u547D\u4EE4\u8D85\u65F6\u65F6\u95F4"),
+        on_finish: z.enum(["poweroff", "release", "keep"]).optional().describe("\u7ED3\u675F\u540E\u52A8\u4F5C\uFF0C\u9ED8\u8BA4 poweroff")
+      },
+      annotations: { destructiveHint: false, idempotentHint: false }
+    },
+    tool(
+      async (input) => {
+        const result = await runWorkflow(client, {
+          command: input.command,
+          gpu: input.gpu,
+          ...input.gpu_num !== void 0 ? { gpuNum: input.gpu_num } : {},
+          ...input.image ? { image: input.image } : {},
+          ...input.regions ? { regions: input.regions } : {},
+          ...input.sync ? { sync: input.sync } : {},
+          ...input.workdir ? { workdir: input.workdir } : {},
+          ...input.pull_from ? { pullFrom: input.pull_from } : {},
+          ...input.pull_to ? { pullTo: input.pull_to } : {},
+          ttlSeconds: parseDuration(input.ttl ?? "4h"),
+          ...input.timeout ? { commandTimeoutMs: parseDuration(input.timeout) * 1e3 } : {},
+          onFinish: input.on_finish ?? "poweroff"
+        });
+        return {
+          instance_uuid: result.instanceUuid,
+          exit_code: result.exitCode,
+          stdout: result.stdout,
+          stderr: result.stderr,
+          uploaded: result.uploaded,
+          downloaded: result.downloaded,
+          final_action: result.finalAction,
+          duration_ms: result.durationMs
+        };
+      }
+    )
+  );
+  server.registerTool(
+    "autodl_gpu_stock",
+    {
+      title: "\u67E5\u8BE2 GPU \u5B9E\u65F6\u5E93\u5B58",
+      description: [
+        "\u6309\u5730\u533A\u67E5\u8BE2 GPU \u7A7A\u95F2\u6570\u91CF\uFF0C\u7528\u4E8E\u5728\u521B\u5EFA\u5B9E\u4F8B\u524D\u6311\u4E00\u4E2A\u6709\u8D27\u7684\u5730\u533A\u3002",
+        "\u6CE8\u610F\uFF1A\u6570\u636E\u6765\u81EA AutoDL \u7684\u300C\u5F39\u6027\u90E8\u7F72 GPU \u5E93\u5B58\u300D\u63A5\u53E3\uFF0C\u4E0E Pro \u5B9E\u4F8B\u80FD\u5426\u521B\u5EFA\u6210\u529F\u6CA1\u6709\u5B98\u65B9\u4FDD\u8BC1\uFF0C\u4EC5\u4F9B\u62E9\u4F18\u53C2\u8003\u2014\u2014\u4E0D\u8981\u636E\u6B64\u5224\u5B9A\u300C\u4E00\u5B9A\u521B\u5EFA\u4E0D\u4E86\u300D\u3002",
+        "autodl_create_instance \u9ED8\u8BA4\u5DF2\u7ECF\u81EA\u52A8\u505A\u4E86\u8FD9\u4EF6\u4E8B\uFF0C\u901A\u5E38\u4E0D\u9700\u8981\u5355\u72EC\u8C03\u7528\u3002"
+      ].join("\n"),
+      inputSchema: {
+        gpu: z.string().optional().describe("\u53EA\u770B\u67D0\u4E2A GPU \u89C4\u683C\uFF0C\u5982 4090 / pro6000-p"),
+        regions: z.array(z.string()).optional().describe("\u5730\u533A\u4EE3\u7801\u5217\u8868\uFF0C\u9ED8\u8BA4\u67E5\u5168\u90E8")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    tool(async (input) => {
+      const spec = input.gpu ? resolveGpuSpec(input.gpu) : void 0;
+      if (input.gpu && !spec) {
+        throw new UsageError(`\u672A\u77E5\u7684 GPU \u89C4\u683C "${input.gpu}"`, {
+          hint: "\u8C03\u7528 autodl_list_gpu_specs \u67E5\u770B\u5168\u90E8\u53EF\u7528\u89C4\u683C\u3002"
+        });
+      }
+      const { snapshots, failures } = await getStockByRegion(client, {
+        ...input.regions?.length ? { regions: input.regions } : {},
+        ...spec ? { gpuNames: [spec.stockName] } : {}
+      });
+      const rentable = new Map(GPU_SPECS.map((s) => [s.stockName, s.id]));
+      const rows = snapshots.flatMap(
+        (snapshot) => snapshot.entries.map((entry) => ({
+          region: snapshot.regionId,
+          region_name: snapshot.regionName,
+          gpu_name: entry.gpuName,
+          // Null means this card cannot be rented through the open API at all.
+          gpu_spec: rentable.get(entry.gpuName) ?? null,
+          idle: entry.idle,
+          total: entry.total
+        }))
+      ).sort((a, b) => b.idle - a.idle);
+      return { rows, failures };
+    })
+  );
+  server.registerTool(
+    "autodl_deploy",
+    {
+      title: "\u90E8\u7F72\u4EE3\u7801\u6258\u7BA1\u5E73\u53F0\u7684\u9879\u76EE",
+      description: [
+        "\u628A\u4E00\u4E2A GitHub / Gitee / GitLab \u4ED3\u5E93\u90E8\u7F72\u5230 AutoDL \u5B9E\u4F8B\u4E0A\uFF1A\u521B\u5EFA\u5B9E\u4F8B \u2192 \u62C9\u4EE3\u7801 \u2192 \u81EA\u52A8\u63A2\u6D4B\u5E76\u5B89\u88C5\u4F9D\u8D56 \u2192 \u53EF\u9009\u542F\u52A8\u3002",
+        "\u4E0E autodl_run \u7684\u5173\u952E\u533A\u522B\uFF1A\u7ED3\u675F\u65F6\u9ED8\u8BA4**\u5173\u673A\u800C\u4E0D\u91CA\u653E**\uFF0C\u5B9E\u4F8B\u6570\u636E\u5B8C\u6574\u4FDD\u7559\u3002",
+        "\u4E0B\u6B21\u5E26 instance_uuid \u518D\u8C03\u4E00\u6B21\u5373\u53EF\u590D\u7528\u540C\u4E00\u53F0\u673A\u5668\uFF08\u5F00\u673A \u2192 git pull \u2192 \u91CD\u65B0\u90E8\u7F72\uFF09\uFF0C\u7701\u6389\u91CD\u5EFA\u73AF\u5883\u7684\u65F6\u95F4\u3002",
+        "\u4EE3\u7801\u653E\u5728\u6570\u636E\u76D8 /root/autodl-tmp/<\u4ED3\u5E93\u540D>\uFF08\u7CFB\u7EDF\u76D8\u53EA\u6709 30G\uFF09\u3002GitHub \u4F1A\u81EA\u52A8\u8D70\u5B66\u672F\u52A0\u901F\u3002",
+        "detach=true \u65F6\u4F1A\u540E\u53F0\u542F\u52A8\u5E76\u8BA9\u5B9E\u4F8B\u4FDD\u6301\u8FD0\u884C\u2014\u2014\u8FD9\u79CD\u60C5\u51B5\u4E0B\u7528\u5B8C\u5FC5\u987B\u81EA\u5DF1\u8C03 autodl_power_off\uFF0C\u5426\u5219\u4F1A\u4E00\u76F4\u8BA1\u8D39\u3002"
+      ].join("\n"),
+      inputSchema: {
+        repo: z.string().describe("\u4ED3\u5E93\u5730\u5740\uFF1Ahttps://github.com/owner/repo\u3001git@... \u6216 owner/repo"),
+        gpu: z.string().optional().describe("GPU \u89C4\u683C\uFF1B\u4E0D\u4F20 instance_uuid \u65F6\u5FC5\u586B"),
+        instance_uuid: z.string().optional().describe("\u590D\u7528\u5DF2\u6709\u5B9E\u4F8B\uFF08\u4E4B\u524D\u90E8\u7F72\u8FC7\u5E76\u5173\u673A\u7684\u90A3\u53F0\uFF09"),
+        branch: z.string().optional(),
+        dir: z.string().optional().describe("\u8FDC\u7A0B\u4EE3\u7801\u76EE\u5F55\uFF0C\u9ED8\u8BA4 /root/autodl-tmp/<\u4ED3\u5E93\u540D>"),
+        setup: z.string().optional().describe("\u81EA\u5B9A\u4E49\u4F9D\u8D56\u5B89\u88C5\u547D\u4EE4\uFF0C\u8986\u76D6\u81EA\u52A8\u63A2\u6D4B"),
+        no_setup: z.boolean().optional().describe("\u8DF3\u8FC7\u4F9D\u8D56\u5B89\u88C5"),
+        start: z.string().optional().describe("\u4F9D\u8D56\u88C5\u597D\u540E\u6267\u884C\u7684\u542F\u52A8\u547D\u4EE4"),
+        detach: z.boolean().optional().describe("\u540E\u53F0\u542F\u52A8\u5E76\u4FDD\u6301\u5B9E\u4F8B\u8FD0\u884C\uFF0C\u9ED8\u8BA4 false"),
+        git_token: z.string().optional().describe("\u79C1\u6709\u4ED3\u5E93\u51ED\u8BC1\uFF08\u654F\u611F\uFF0C\u4E0D\u4F1A\u88AB\u56DE\u663E\uFF09"),
+        regions: z.array(z.string()).optional(),
+        ttl: z.string().optional().describe("\u5230\u671F\u81EA\u52A8\u5173\u673A\u65F6\u957F\uFF0C\u9ED8\u8BA4 4h"),
+        on_finish: z.enum(["poweroff", "release", "keep"]).optional().describe("\u7ED3\u675F\u52A8\u4F5C\uFF0C\u9ED8\u8BA4 poweroff\uFF08\u5173\u673A\u4FDD\u7559\u6570\u636E\uFF09"),
+        timeout: z.string().optional().describe("\u5355\u6761\u8FDC\u7A0B\u547D\u4EE4\u8D85\u65F6\u65F6\u95F4")
+      },
+      annotations: { destructiveHint: false, idempotentHint: false }
+    },
+    tool(
+      async (input) => {
+        const token = resolveGitToken(input.git_token);
+        const result = await deployWorkflow(client, {
+          repo: input.repo,
+          ...input.gpu ? { gpu: input.gpu } : {},
+          ...input.instance_uuid ? { instanceUuid: input.instance_uuid } : {},
+          ...input.branch ? { branch: input.branch } : {},
+          ...input.dir ? { dir: input.dir } : {},
+          ...input.setup ? { setup: input.setup } : {},
+          noSetup: input.no_setup === true,
+          ...input.start ? { start: input.start } : {},
+          detach: input.detach === true,
+          ...token ? { gitToken: token } : {},
+          ...input.regions?.length ? { regions: input.regions } : {},
+          ttlSeconds: parseDuration(input.ttl ?? "4h"),
+          onFinish: input.on_finish ?? "poweroff",
+          ...input.timeout ? { commandTimeoutMs: parseDuration(input.timeout) * 1e3 } : {}
+        });
+        return {
+          instance_uuid: result.instanceUuid,
+          created: result.created,
+          repo: result.repo,
+          dir: result.dir,
+          setup_command: result.setupCommand,
+          start_command: result.startCommand,
+          detached: result.detached,
+          exit_code: result.exitCode,
+          stdout: result.stdout,
+          stderr: result.stderr,
+          access: result.access,
+          final_action: result.finalAction,
+          duration_ms: result.durationMs,
+          note: result.detached ? `\u5B9E\u4F8B\u4FDD\u6301\u8FD0\u884C\u4E2D\uFF0C\u7528\u5B8C\u8BF7\u8C03\u7528 autodl_power_off("${result.instanceUuid}") \u505C\u6B62\u8BA1\u8D39\u3002` : `\u5B9E\u4F8B\u5DF2\u5173\u673A\u3001\u6570\u636E\u4FDD\u7559\u3002\u590D\u7528\uFF1A\u518D\u6B21\u8C03\u7528\u672C\u5DE5\u5177\u5E76\u4F20 instance_uuid="${result.instanceUuid}"\u3002`
+        };
+      }
+    )
+  );
+  server.registerTool(
+    "autodl_list_gpu_specs",
+    {
+      title: "\u5217\u51FA\u53EF\u7528 GPU \u89C4\u683C",
+      description: "\u5217\u51FA\u5B98\u65B9\u5F00\u653E API \u652F\u6301\u7684\u5168\u90E8 GPU \u89C4\u683C\u3002\u6CE8\u610F\u5B98\u65B9\u6CA1\u6709\u5E93\u5B58\u63A5\u53E3\uFF0C\u6709\u8D27\u4E0E\u5426\u53EA\u80FD\u521B\u5EFA\u65F6\u624D\u77E5\u9053\u3002",
+      inputSchema: {},
+      annotations: { readOnlyHint: true }
+    },
+    tool(async () => ({ gpu_specs: GPU_SPECS, regions: REGIONS }))
+  );
+  server.registerTool(
+    "autodl_list_images",
+    {
+      title: "\u5217\u51FA\u955C\u50CF",
+      description: "\u5217\u51FA\u5B98\u65B9\u516C\u5171\u57FA\u7840\u955C\u50CF\uFF0C\u6216\u8D26\u53F7\u4E0B\u7684\u79C1\u6709\u955C\u50CF\u3002",
+      inputSchema: {
+        kind: z.enum(["base", "private"]).optional().describe("\u9ED8\u8BA4 base\uFF08\u516C\u5171\u57FA\u7840\u955C\u50CF\uFF09")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    tool(async ({ kind }) => {
+      if (kind === "private") {
+        const { images } = await listPrivateImages(client, { pageSize: 100 });
+        return { kind: "private", images };
+      }
+      return { kind: "base", images: BASE_IMAGES };
+    })
+  );
+  server.registerTool(
+    "autodl_save_image",
+    {
+      title: "\u4FDD\u5B58\u5B9E\u4F8B\u4E3A\u79C1\u6709\u955C\u50CF",
+      description: "\u628A\u5B9E\u4F8B\u5F53\u524D\u72B6\u6001\u4FDD\u5B58\u6210\u53EF\u590D\u7528\u7684\u79C1\u6709\u955C\u50CF\u3002\u4FDD\u5B58\u8FC7\u7A0B\u9700\u8981\u4E00\u6BB5\u65F6\u95F4\uFF0C\u4E4B\u540E\u7528 autodl_list_images \u67E5\u72B6\u6001\u3002",
+      inputSchema: { instance_uuid: z.string(), image_name: z.string() }
+    },
+    tool(async ({ instance_uuid, image_name }) => ({
+      instance_uuid,
+      image_uuid: await saveImage(client, instance_uuid, image_name)
+    }))
+  );
+  server.registerTool(
+    "autodl_sweep_expired",
+    {
+      title: "\u6E05\u7406\u8D85\u65F6\u5B9E\u4F8B",
+      description: "\u5173\u95ED\u672C\u673A\u8BB0\u5F55\u4E2D\u6240\u6709\u5DF2\u8D85\u8FC7 TTL \u4F46\u4ECD\u5728\u8FD0\u884C\u7684\u5B9E\u4F8B\u3002\u7528\u4E8E\u6536\u5C3E\u515C\u5E95\u3002",
+      inputSchema: {}
+    },
+    tool(async () => sweepExpired(client))
+  );
+  server.registerResource(
+    "instances",
+    "autodl://instances",
+    {
+      title: "AutoDL \u5B9E\u4F8B\u5217\u8868",
+      description: "\u5F53\u524D\u8D26\u53F7\u4E0B\u6240\u6709\u5B9E\u4F8B\u7684\u5B9E\u65F6\u5FEB\u7167\uFF08JSON\uFF09\u3002",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const instances = await listAllInstances(client);
+      return {
+        contents: [
+          { uri: uri.href, mimeType: "application/json", text: JSON.stringify(instances, null, 2) }
+        ]
+      };
+    }
+  );
+  return server;
+}
+async function startMcpServer(options = {}) {
+  const context = createContext({
+    ...options.token ? { token: options.token } : {},
+    ...options.baseUrl ? { baseUrl: options.baseUrl } : {},
+    json: true,
+    sweep: false
+  });
+  const server = buildServer(context);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/ssh/connect.ts
+import { spawn } from "child_process";
+async function connectInteractive(client, uuid, options = {}) {
+  const creds = await getCredentials(client, uuid, options);
+  const args = [
+    "-p",
+    String(creds.port),
+    // The proxy hosts recycle host keys across instances, so strict checking would
+    // fail on every new rental and train users to ignore the warning.
+    "-o",
+    "StrictHostKeyChecking=no",
+    "-o",
+    "UserKnownHostsFile=/dev/null",
+    "-o",
+    "LogLevel=ERROR",
+    ...options.extraArgs ?? [],
+    `${creds.user}@${creds.host}`
+  ];
+  note(`ssh -p ${creds.port} ${creds.user}@${creds.host}`);
+  note(`\u5BC6\u7801\uFF1A${creds.password}`);
+  return new Promise((resolve, reject) => {
+    const child = spawn("ssh", args, { stdio: "inherit" });
+    child.on(
+      "error",
+      (err) => reject(
+        new SSHError(`\u65E0\u6CD5\u542F\u52A8 ssh \u5BA2\u6237\u7AEF\uFF1A${err.message}`, {
+          hint: "\u786E\u8BA4\u7CFB\u7EDF\u5DF2\u5B89\u88C5 OpenSSH \u5BA2\u6237\u7AEF\uFF08which ssh\uFF09\u3002",
+          cause: err
+        })
+      )
+    );
+    child.on("close", (code) => resolve(code ?? 0));
+  });
+}
+function formatSSHCommand(creds) {
+  return `ssh -p ${creds.port} ${creds.user}@${creds.host}`;
+}
+
+export {
+  saveImage,
+  listPrivateImages,
+  parseRepo,
+  withCredentials,
+  redactCredentials,
+  resolveGitToken,
+  resolveMinBalance,
+  assertBudget,
+  parseUtilisation,
+  watchIdle,
+  push,
+  pull,
+  deployWorkflow,
+  runWorkflow,
+  buildServer,
+  startMcpServer,
+  connectInteractive,
+  formatSSHCommand
+};
+//# sourceMappingURL=chunk-5RZ4Q7T4.js.map