@minato-aqukin/autodl-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1058 @@
+#!/usr/bin/env node
+import { createRequire as __nodeCreateRequire } from "node:module";
+const require = __nodeCreateRequire(import.meta.url);
+import {
+  assertBudget,
+  connectInteractive,
+  deployWorkflow,
+  listPrivateImages,
+  pull,
+  push,
+  resolveGitToken,
+  runWorkflow,
+  saveImage,
+  startMcpServer,
+  watchIdle
+} from "./chunk-5RZ4Q7T4.js";
+import {
+  BASE_IMAGES,
+  DEFAULT_BASE_IMAGE,
+  GPU_SPECS,
+  PRO_CREATE_REGIONS,
+  REGIONS,
+  VERSION,
+  assertProCreateRegion,
+  chooseRegions,
+  findBaseImage,
+  getBalance,
+  getStockByRegion,
+  parseCudaVersion,
+  resolveGpuSpec,
+  resolveRegion
+} from "./chunk-CWCG3MOC.js";
+import {
+  action,
+  bareAction,
+  confirmDestructive,
+  globalsOf,
+  lazyAction,
+  registerTuiCommand
+} from "./chunk-2TWWLI3Y.js";
+import "./chunk-NBWWTYSL.js";
+import {
+  AutoDLClient,
+  ExitCode,
+  UsageError,
+  armTTLOverSSH,
+  clearToken,
+  colorStatus,
+  composeStartCommand,
+  configPath,
+  configureOutput,
+  createInstance,
+  disarmTTLOverSSH,
+  emit,
+  emitError,
+  execCommand,
+  findInstance,
+  formatBytes,
+  formatDuration,
+  formatRate,
+  formatTime,
+  formatYuan,
+  getCredentials,
+  getInstanceSnapshot,
+  getInstanceStatus,
+  isJson,
+  listAllInstances,
+  listTracked,
+  note,
+  parseDuration,
+  powerOffInstance,
+  powerOnInstance,
+  printKeyValues,
+  printTable,
+  readConfig,
+  recordTTL,
+  redactToken,
+  releaseInstance,
+  resolveLang,
+  setLang,
+  success,
+  sweepExpired,
+  t,
+  toAutoDLError,
+  untrackInstance,
+  updateConfig,
+  waitForRunning,
+  waitForShutdown,
+  warn
+} from "./chunk-6QR4ZYQR.js";
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/account.ts
+function registerAccountCommands(program) {
+  program.command("account").alias("balance").description("\u67E5\u770B\u8D26\u53F7\u4F59\u989D\u3001\u7D2F\u8BA1\u6D88\u8D39\u4E0E\u4EE3\u91D1\u5238").action(
+    action(async (context) => {
+      const balance = await getBalance(context.client);
+      emit({ ...balance, spendableYuan: balance.balanceYuan + balance.voucherYuan }, () => {
+        printKeyValues([
+          [t("account.balance"), formatYuan(balance.balanceYuan)],
+          [t("account.voucher"), formatYuan(balance.voucherYuan)],
+          [t("account.accumulated"), formatYuan(balance.accumulatedYuan)]
+        ]);
+      });
+      return 0;
+    })
+  );
+}
+
+// src/commands/auth.ts
+import { intro, isCancel, outro, password, spinner } from "@clack/prompts";
+import pc from "picocolors";
+function registerAuthCommands(program) {
+  program.command("login").description("\u914D\u7F6E AutoDL \u5F00\u53D1\u8005 Token").option("--token <token>", "\u76F4\u63A5\u63D0\u4F9B Token\uFF0C\u8DF3\u8FC7\u4EA4\u4E92\u5F0F\u8F93\u5165").action(
+    bareAction(async (globals, options) => {
+      setLang(resolveLang(globals.lang));
+      configureOutput({ json: globals.json ?? false, color: globals.color ?? true });
+      let token = options.token ?? globals.token;
+      if (!token) {
+        if (isJson() || !process.stdin.isTTY) {
+          throw new UsageError("\u975E\u4EA4\u4E92\u73AF\u5883\u4E0B\u5FC5\u987B\u901A\u8FC7 --token \u63D0\u4F9B Token", {
+            hint: "\u4F8B\u5982\uFF1Aautodl login --token <\u4F60\u7684Token>\uFF0C\u6216\u76F4\u63A5\u8BBE\u7F6E AUTODL_TOKEN \u73AF\u5883\u53D8\u91CF\u3002"
+          });
+        }
+        intro(pc.bold("AutoDL \u767B\u5F55"));
+        const answer = await password({
+          message: `${t("login.prompt")}
+  ${pc.dim(t("login.hint"))}`
+        });
+        if (isCancel(answer)) {
+          outro(t("login.cancelled"));
+          return 0;
+        }
+        token = String(answer);
+      }
+      const spin = isJson() ? null : spinner();
+      spin?.start(t("login.verifying"));
+      const client = new AutoDLClient({ token });
+      let balance;
+      try {
+        balance = await getBalance(client);
+      } catch (err) {
+        spin?.stop("\u9A8C\u8BC1\u5931\u8D25", 1);
+        throw err;
+      }
+      spin?.stop("Token \u6709\u6548");
+      updateConfig({ token });
+      emit(
+        {
+          saved: true,
+          configPath: configPath(),
+          token: redactToken(token),
+          balanceYuan: balance.balanceYuan
+        },
+        () => {
+          success(`${t("login.success")} ${configPath()}`);
+          printKeyValues([
+            [t("account.balance"), formatYuan(balance.balanceYuan)],
+            ["Token", redactToken(token)]
+          ]);
+        }
+      );
+      return 0;
+    })
+  );
+  program.command("logout").description("\u6E05\u9664\u672C\u5730\u4FDD\u5B58\u7684 Token").action(
+    bareAction(async (globals) => {
+      setLang(resolveLang(globals.lang));
+      configureOutput({ json: globals.json ?? false, color: globals.color ?? true });
+      clearToken();
+      emit({ cleared: true, configPath: configPath() }, () => success(t("logout.done")));
+      return 0;
+    })
+  );
+  program.command("whoami").description("\u663E\u793A\u5F53\u524D Token \u6765\u6E90\u4E0E\u8D26\u53F7\u53EF\u7528\u4F59\u989D").action(
+    action(
+      async (context) => {
+        const balance = await getBalance(context.client);
+        const stored = readConfig().token;
+        const source = process.env.AUTODL_TOKEN ? "env:AUTODL_TOKEN" : stored ? `config:${configPath()}` : "flag";
+        emit({ tokenSource: source, token: context.client.maskedToken, ...balance }, () => {
+          printKeyValues([
+            ["Token", context.client.maskedToken],
+            ["\u6765\u6E90", source],
+            [t("account.balance"), formatYuan(balance.balanceYuan)]
+          ]);
+        });
+        return 0;
+      },
+      { sweep: false }
+    )
+  );
+}
+
+// src/commands/catalog.ts
+import pc2 from "picocolors";
+function registerCatalogCommands(program) {
+  program.command("gpus").description("\u5217\u51FA\u5B98\u65B9\u5F00\u653E API \u652F\u6301\u7684 GPU \u89C4\u683C").action(
+    lazyAction(async () => {
+      emit([...GPU_SPECS], () => {
+        printTable(
+          ["\u89C4\u683C ID", "\u578B\u53F7", "\u7C7B\u578B", "\u663E\u5B58", "\u522B\u540D"],
+          GPU_SPECS.map((spec) => [
+            spec.id,
+            spec.displayName,
+            spec.tier === "general" ? "\u901A\u7528\u578B" : "\u6027\u80FD\u578B",
+            `${spec.vramGb}G`,
+            spec.aliases.join(", ")
+          ])
+        );
+        note(
+          pc2.dim(
+            "\u5B98\u65B9 API \u6CA1\u6709\u5E93\u5B58\u67E5\u8BE2\u63A5\u53E3\uFF0C\u521B\u5EFA\u5B9E\u4F8B\u53EA\u80FD\u76F4\u63A5\u5C1D\u8BD5\uFF1B\u65E0\u8D27\u65F6\u4F1A\u8FD4\u56DE NO_STOCK\uFF08\u9000\u51FA\u7801 6\uFF09\u3002"
+          )
+        );
+      });
+      return 0;
+    })
+  );
+  program.command("regions").description("\u5217\u51FA\u53EF\u7528\u5730\u533A\u4EE3\u7801").action(
+    lazyAction(async () => {
+      emit([...REGIONS], () => {
+        printTable(
+          ["\u5730\u533A\u4EE3\u7801", "\u540D\u79F0", "\u522B\u540D"],
+          REGIONS.map((region) => [region.id, region.displayName, region.aliases.join(", ")])
+        );
+      });
+      return 0;
+    })
+  );
+  program.command("images").description("\u5217\u51FA\u955C\u50CF\uFF08\u9ED8\u8BA4\u663E\u793A\u79C1\u6709\u955C\u50CF\uFF0C--base \u663E\u793A\u5B98\u65B9\u516C\u5171\u57FA\u7840\u955C\u50CF\uFF09").option("--base", "\u663E\u793A\u5B98\u65B9\u516C\u5171\u57FA\u7840\u955C\u50CF").option("--page <n>", "\u9875\u7801", "1").option("--page-size <n>", "\u6BCF\u9875\u6761\u6570", "50").action(
+    lazyAction(
+      async (getContext, options) => {
+        if (options.base) {
+          emit([...BASE_IMAGES], () => {
+            printTable(
+              ["\u955C\u50CF UUID", "\u6846\u67B6", "CUDA", "Python", "\u6807\u7B7E"],
+              BASE_IMAGES.map((image) => [
+                image.uuid,
+                image.framework,
+                image.cuda,
+                image.python,
+                image.tag
+              ])
+            );
+            note(pc2.dim("\u8FD9\u4E9B\u662F\u5185\u7F6E\u7684\u9759\u6001\u8868\uFF0C\u82E5\u5E73\u53F0\u5DF2\u66F4\u65B0\u8BF7\u5230\u4ED3\u5E93\u63D0 issue\u3002"));
+          });
+          return 0;
+        }
+        const { images, pagination } = await listPrivateImages(getContext().client, {
+          pageIndex: Number(options.page),
+          pageSize: Number(options.pageSize)
+        });
+        emit({ images, pagination }, () => {
+          if (images.length === 0) {
+            note("\u5F53\u524D\u8D26\u53F7\u6CA1\u6709\u79C1\u6709\u955C\u50CF");
+            return;
+          }
+          printTable(
+            ["\u955C\u50CF UUID", "\u540D\u79F0", "\u72B6\u6001", "\u5927\u5C0F", "\u521B\u5EFA\u65F6\u95F4"],
+            images.map((image) => [
+              image.imageUuid,
+              image.name,
+              image.status ?? "-",
+              formatBytes(image.sizeBytes),
+              formatTime(image.createdAt)
+            ])
+          );
+        });
+        return 0;
+      }
+    )
+  );
+}
+
+// src/commands/deploy.ts
+import pc3 from "picocolors";
+function registerDeployCommand(program) {
+  program.command("deploy <repo>").description(
+    "\u5F00\u5361\u90E8\u7F72\u4EE3\u7801\u6258\u7BA1\u5E73\u53F0\u7684\u9879\u76EE\uFF1A\u5EFA\u5B9E\u4F8B \u2192 \u62C9\u4EE3\u7801 \u2192 \u88C5\u4F9D\u8D56 \u2192 \u542F\u52A8 \u2192\uFF08\u9ED8\u8BA4\uFF09\u5173\u673A\u4FDD\u7559\u6570\u636E"
+  ).option("--gpu <spec>", "GPU \u89C4\u683C\uFF1B\u4E0D\u6307\u5B9A --instance \u65F6\u5FC5\u586B").option("--instance <id>", "\u590D\u7528\u5DF2\u6709\u5B9E\u4F8B\uFF1A\u5F00\u673A \u2192 git pull \u2192 \u91CD\u65B0\u90E8\u7F72").option("--branch <name>", "\u5206\u652F\u6216\u6807\u7B7E").option("--dir <path>", "\u8FDC\u7A0B\u4EE3\u7801\u76EE\u5F55\uFF0C\u9ED8\u8BA4 /root/autodl-tmp/<\u4ED3\u5E93\u540D>").option("--setup <cmd>", "\u81EA\u5B9A\u4E49\u4F9D\u8D56\u5B89\u88C5\u547D\u4EE4\uFF0C\u8986\u76D6\u81EA\u52A8\u63A2\u6D4B").option("--no-setup", "\u8DF3\u8FC7\u4F9D\u8D56\u5B89\u88C5").option("--start <cmd>", "\u4F9D\u8D56\u88C5\u597D\u540E\u6267\u884C\u7684\u542F\u52A8\u547D\u4EE4").option("--detach", "\u540E\u53F0\u542F\u52A8\u5E76\u7ACB\u5373\u8FD4\u56DE\uFF08\u5B9E\u4F8B\u4FDD\u6301\u8FD0\u884C\uFF09", false).option("--git-token <token>", "\u79C1\u6709\u4ED3\u5E93\u51ED\u8BC1\uFF0C\u4E5F\u53EF\u7528 GIT_TOKEN / GITHUB_TOKEN \u73AF\u5883\u53D8\u91CF").option("--no-accel", "\u5173\u95ED\u5B66\u672F\u8D44\u6E90\u52A0\u901F").option("--num <n>", "GPU \u6570\u91CF\uFF081-4\uFF09", "1").option("--image <uuid>", "\u955C\u50CF UUID \u6216\u516C\u5171\u955C\u50CF\u6807\u7B7E").option("--region <code...>", "\u9650\u5B9A\u5730\u533A\uFF0C\u9ED8\u8BA4\u6309\u5E93\u5B58\u81EA\u52A8\u62E9\u4F18").option("--disk <gb>", "\u7CFB\u7EDF\u76D8\u6269\u5BB9 GB", "0").option("--name <name>", "\u5B9E\u4F8B\u540D\u79F0\uFF0C\u9ED8\u8BA4\u53D6\u4ED3\u5E93\u540D").option("--ttl <duration>", "\u5230\u671F\u81EA\u52A8\u5173\u673A", "4h").option("--on-finish <action>", "\u7ED3\u675F\u540E\u52A8\u4F5C\uFF1Apoweroff / release / keep", "poweroff").option("--timeout <duration>", "\u5355\u6761\u8FDC\u7A0B\u547D\u4EE4\u8D85\u65F6\u65F6\u95F4").option("--min-balance <yuan>", "\u4F59\u989D\u4F4E\u4E8E\u8BE5\u503C\u65F6\u62D2\u7EDD\u521B\u5EFA").option("--no-stock-check", "\u8DF3\u8FC7\u521B\u5EFA\u524D\u7684 GPU \u5E93\u5B58\u67E5\u8BE2").option("--env <key=value...>", "\u6CE8\u5165\u73AF\u5883\u53D8\u91CF").action(
+    action(async (context, repo, options) => {
+      const env = {};
+      for (const pair of options.env ?? []) {
+        const index = pair.indexOf("=");
+        if (index > 0) env[pair.slice(0, index)] = pair.slice(index + 1);
+      }
+      if (!["poweroff", "release", "keep"].includes(options.onFinish)) {
+        warn(`\u672A\u77E5\u7684 --on-finish "${options.onFinish}"\uFF0C\u6309 poweroff \u5904\u7406`);
+      }
+      const controller = new AbortController();
+      let interrupted = false;
+      const onSigint = () => {
+        if (interrupted) return;
+        interrupted = true;
+        warn("\u6536\u5230\u4E2D\u65AD\u4FE1\u53F7\uFF0C\u6B63\u5728\u5B89\u5168\u6536\u5C3E\u2026");
+        controller.abort();
+      };
+      process.on("SIGINT", onSigint);
+      process.on("SIGTERM", onSigint);
+      try {
+        const deployOptions = {
+          repo,
+          ...options.gpu ? { gpu: options.gpu } : {},
+          ...options.instance ? { instanceUuid: options.instance } : {},
+          ...options.branch ? { branch: options.branch } : {},
+          gpuNum: Number(options.num),
+          ...options.image ? { image: options.image } : {},
+          ...options.region ? { regions: options.region } : {},
+          diskGb: Number(options.disk),
+          ...options.name ? { name: options.name } : {},
+          ...options.dir ? { dir: options.dir } : {},
+          ...options.setup ? { setup: options.setup } : {},
+          noSetup: options.noSetup === true,
+          ...options.start ? { start: options.start } : {},
+          detach: options.detach,
+          ...resolveGitToken(options.gitToken) ? { gitToken: resolveGitToken(options.gitToken) } : {},
+          noAcceleration: options.noAccel === true,
+          ttlSeconds: parseDuration(options.ttl),
+          onFinish: ["poweroff", "release", "keep"].includes(options.onFinish) ? options.onFinish : "poweroff",
+          ...options.timeout ? { commandTimeoutMs: parseDuration(options.timeout) * 1e3 } : {},
+          ...options.minBalance !== void 0 ? { minBalanceYuan: Number(options.minBalance) } : {},
+          ...options.stockCheck === false ? { stockCheck: false } : {},
+          ...Object.keys(env).length ? { env } : {},
+          signal: controller.signal
+        };
+        const result = await deployWorkflow(context.client, deployOptions);
+        emit(result, () => {
+          note(`\u7528\u65F6 ${formatDuration(Math.round(result.durationMs / 1e3))}`);
+          if (result.detached) {
+            success("\u9879\u76EE\u5DF2\u5728\u540E\u53F0\u8FD0\u884C");
+            for (const url of result.access.publicUrls) note(`  \u516C\u7F51\u8BBF\u95EE\uFF1A${url}`);
+            if (result.access.tunnelHint) {
+              note(`  ${pc3.dim("\u516C\u7F51\u6620\u5C04\u9700\u4F01\u4E1A\u8BA4\u8BC1\uFF0C\u4E2A\u4EBA\u8D26\u53F7\u8BF7\u7528 SSH \u96A7\u9053\uFF1A")}`);
+              note(`  ${result.access.tunnelHint}`);
+            }
+            if (result.access.logHint) note(`  \u67E5\u770B\u65E5\u5FD7\uFF1A${result.access.logHint}`);
+          } else if (result.startCommand) {
+            if (result.exitCode === 0) success("\u9879\u76EE\u6267\u884C\u6210\u529F");
+            else warn(`\u9879\u76EE\u9000\u51FA\u7801 ${result.exitCode}`);
+          } else {
+            success(`\u90E8\u7F72\u5B8C\u6210\uFF1A${result.dir}`);
+          }
+          if (result.finalAction === "poweroff" && !result.detached) {
+            note(`\u4E0B\u6B21\u76F4\u63A5\u590D\u7528\uFF1Aautodl deploy ${repo} --instance ${result.instanceUuid}`);
+          }
+        });
+        return result.startCommand && !result.detached ? result.exitCode ?? 1 : 0;
+      } finally {
+        process.off("SIGINT", onSigint);
+        process.off("SIGTERM", onSigint);
+      }
+    })
+  );
+}
+
+// src/commands/guard.ts
+import pc4 from "picocolors";
+function registerGuardCommands(program) {
+  const guard = program.command("guard").description("\u6210\u672C\u62A4\u680F\uFF1A\u5B9A\u65F6\u5173\u673A\u3001\u95F2\u7F6E\u68C0\u6D4B\u3001\u8D85\u65F6\u6E05\u7406");
+  guard.command("ttl <id> <duration>").description("\u4E3A\u8FD0\u884C\u4E2D\u7684\u5B9E\u4F8B\u8BBE\u7F6E\u5230\u671F\u81EA\u52A8\u5173\u673A\uFF0C\u5982 `autodl guard ttl pro-xxx 2h`").action(
+    action(async (context, id, duration) => {
+      const seconds = parseDuration(duration);
+      const armed = await armTTLOverSSH(context.client, id, seconds);
+      recordTTL({ uuid: id, ttlSeconds: seconds, inInstanceTimer: armed });
+      if (!armed) warn(t("guard.armFailed"));
+      emit(
+        { uuid: id, ttlSeconds: seconds, inInstanceTimer: armed },
+        () => success(`${t("guard.armed")}\uFF1A${formatDuration(seconds)} \u540E\u81EA\u52A8\u5173\u673A`)
+      );
+      return 0;
+    })
+  );
+  guard.command("cancel <id>").description("\u53D6\u6D88\u5B9E\u4F8B\u5185\u7684\u5B9A\u65F6\u5173\u673A").action(
+    action(async (context, id) => {
+      const ok = await disarmTTLOverSSH(context.client, id);
+      emit(
+        { uuid: id, cancelled: ok },
+        () => ok ? success("\u5DF2\u53D6\u6D88\u5B9A\u65F6\u5173\u673A") : warn("\u672A\u80FD\u786E\u8BA4\u53D6\u6D88\u7ED3\u679C\uFF0C\u8BF7\u624B\u52A8\u68C0\u67E5\u5B9E\u4F8B\u5185\u5B9A\u65F6\u4EFB\u52A1")
+      );
+      return 0;
+    })
+  );
+  guard.command("idle <id>").description("\u6301\u7EED\u91C7\u6837 GPU \u5229\u7528\u7387\uFF0C\u95F2\u7F6E\u8DB3\u591F\u4E45\u540E\u81EA\u52A8\u5173\u673A").option("--threshold <percent>", "\u5224\u5B9A\u4E3A\u95F2\u7F6E\u7684\u5229\u7528\u7387\u4E0A\u9650", "5").option("--samples <n>", "\u8FDE\u7EED\u95F2\u7F6E\u591A\u5C11\u6B21\u540E\u5173\u673A", "6").option("--interval <duration>", "\u91C7\u6837\u95F4\u9694", "1m").option("--dry-run", "\u53EA\u62A5\u544A\u4E0D\u5173\u673A", false).action(
+    action(
+      async (context, id, options) => {
+        const controller = new AbortController();
+        const onSigint = () => controller.abort();
+        process.once("SIGINT", onSigint);
+        try {
+          const result = await watchIdle(context.client, id, {
+            thresholdPercent: Number(options.threshold),
+            samples: Number(options.samples),
+            intervalSeconds: parseDuration(options.interval),
+            dryRun: options.dryRun,
+            signal: controller.signal,
+            onSample: (utilisation, consecutive) => note(
+              pc4.dim(
+                `GPU ${utilisation.toFixed(1)}%\uFF08\u8FDE\u7EED\u95F2\u7F6E ${consecutive}/${options.samples}\uFF09`
+              )
+            )
+          });
+          emit({ uuid: id, ...result }, () => {
+            if (result.stopped) success(`\u5B9E\u4F8B ${id} \u56E0\u6301\u7EED\u95F2\u7F6E\u5DF2\u81EA\u52A8\u5173\u673A`);
+            else note(`\u95F2\u7F6E\u68C0\u6D4B\u7ED3\u675F\uFF1A${result.reason}`);
+          });
+          return 0;
+        } finally {
+          process.off("SIGINT", onSigint);
+        }
+      }
+    )
+  );
+  guard.command("list").description("\u5217\u51FA\u672C\u673A\u8BB0\u5F55\u7684 TTL \u53F0\u8D26").action(
+    lazyAction(async () => {
+      const tracked = listTracked();
+      emit(tracked, () => {
+        if (tracked.length === 0) {
+          note("\u672C\u673A\u6CA1\u6709\u8BB0\u5F55\u4EFB\u4F55\u5E26 TTL \u7684\u5B9E\u4F8B");
+          return;
+        }
+        const now = Date.now();
+        printTable(
+          ["\u5B9E\u4F8B ID", "\u540D\u79F0", "TTL", "\u5269\u4F59", "\u5B9E\u4F8B\u5185\u5B9A\u65F6\u5668"],
+          tracked.map((entry) => [
+            entry.uuid,
+            entry.name ?? "-",
+            formatDuration(entry.ttlSeconds),
+            entry.expiresAt <= now ? pc4.red("\u5DF2\u8D85\u65F6") : formatDuration(Math.round((entry.expiresAt - now) / 1e3)),
+            entry.inInstanceTimer ? "\u5DF2\u8BBE\u7F6E" : pc4.yellow("\u672A\u8BBE\u7F6E")
+          ])
+        );
+      });
+      return 0;
+    })
+  );
+  guard.command("sweep").description("\u7ACB\u5373\u6E05\u7406\u6240\u6709\u8D85\u65F6\u5B9E\u4F8B").action(
+    action(
+      async (context) => {
+        const result = await sweepExpired(context.client);
+        emit(result, () => {
+          if (result.stopped.length === 0 && result.failed.length === 0) {
+            note("\u6CA1\u6709\u9700\u8981\u6E05\u7406\u7684\u8D85\u65F6\u5B9E\u4F8B");
+            return;
+          }
+          if (result.stopped.length) success(`\u5DF2\u5173\u95ED ${result.stopped.length} \u4E2A\u8D85\u65F6\u5B9E\u4F8B`);
+          for (const failure of result.failed) warn(`${failure.uuid}\uFF1A${failure.reason}`);
+        });
+        return 0;
+      },
+      { sweep: false }
+    )
+  );
+  const image = program.command("image").description("\u955C\u50CF\u7BA1\u7406");
+  image.command("save <id> <name>").description("\u628A\u5B9E\u4F8B\u4FDD\u5B58\u4E3A\u79C1\u6709\u955C\u50CF").action(
+    action(async (context, id, name) => {
+      const imageUuid = await saveImage(context.client, id, name);
+      emit(
+        { instanceUuid: id, imageUuid, name },
+        () => success(
+          `\u955C\u50CF\u4FDD\u5B58\u5DF2\u63D0\u4EA4\uFF1A${imageUuid}\uFF08\u4FDD\u5B58\u9700\u8981\u4E00\u6BB5\u65F6\u95F4\uFF0C\u7528 \`autodl images\` \u67E5\u770B\u72B6\u6001\uFF09`
+        )
+      );
+      return 0;
+    })
+  );
+}
+
+// src/commands/instances.ts
+import { spinner as spinner2 } from "@clack/prompts";
+import pc5 from "picocolors";
+function registerInstanceCommands(program) {
+  program.command("ls").alias("list").description("\u5217\u51FA\u8D26\u53F7\u4E0B\u7684\u6240\u6709\u5B9E\u4F8B").option("--status <status>", "\u6309\u72B6\u6001\u8FC7\u6EE4\uFF0C\u5982 running / shutdown").action(
+    action(async (context, options) => {
+      let instances = await listAllInstances(context.client);
+      if (options.status) {
+        instances = instances.filter((instance) => instance.status === options.status);
+      }
+      emit(instances, () => {
+        if (instances.length === 0) {
+          note(t("instance.none"));
+          return;
+        }
+        printTable(
+          ["\u5B9E\u4F8B ID", "\u540D\u79F0", "\u72B6\u6001", "GPU", "\u5730\u533A", "\u521B\u5EFA\u65F6\u95F4"],
+          instances.map((instance) => [
+            instance.uuid,
+            instance.name ?? "-",
+            colorStatus(instance.status),
+            `${instance.gpuSpec ?? "-"} \xD7${instance.gpuNum}`,
+            instance.regionName ?? instance.regionSign ?? "-",
+            formatTime(instance.createdAt)
+          ])
+        );
+      });
+      return 0;
+    })
+  );
+  program.command("info <id>").description("\u67E5\u770B\u5B9E\u4F8B\u8BE6\u60C5\uFF0C\u542B SSH \u8FDE\u63A5\u4FE1\u606F").option("--show-password", "\u5728\u8F93\u51FA\u4E2D\u663E\u793A root \u5BC6\u7801\u660E\u6587", false).action(
+    action(async (context, id, options) => {
+      const [instance, snapshot] = await Promise.all([
+        findInstance(context.client, id),
+        getInstanceSnapshot(context.client, id).catch(() => null)
+      ]);
+      const payload = {
+        instance,
+        snapshot: snapshot && !options.showPassword ? {
+          ...snapshot,
+          ssh: { ...snapshot.ssh, password: snapshot.ssh.password ? "***" : null }
+        } : snapshot
+      };
+      emit(payload, () => {
+        printKeyValues([
+          ["\u5B9E\u4F8B ID", instance.uuid],
+          ["\u540D\u79F0", instance.name ?? "-"],
+          ["\u72B6\u6001", colorStatus(instance.status)],
+          ["GPU", `${instance.gpuSpec ?? "-"} \xD7${instance.gpuNum}`],
+          ["\u5730\u533A", instance.regionName ?? instance.regionSign ?? "-"],
+          ["\u8BA1\u8D39\u65B9\u5F0F", instance.chargeType ?? "-"],
+          ["\u521B\u5EFA\u65F6\u95F4", formatTime(instance.createdAt)],
+          ["\u5F00\u673A\u65F6\u95F4", formatTime(instance.startedAt)]
+        ]);
+        if (!snapshot) {
+          note(pc5.dim("\n\u5B9E\u4F8B\u672A\u8FD0\u884C\uFF0C\u6682\u65E0 SSH \u4FE1\u606F\u3002"));
+          return;
+        }
+        process.stdout.write("\n");
+        printKeyValues([
+          ["\u5355\u4EF7", snapshot.priceYuanPerHour ? formatRate(snapshot.priceYuanPerHour) : "-"],
+          ["SSH", snapshot.ssh.command ?? "-"],
+          [
+            "\u5BC6\u7801",
+            options.showPassword ? snapshot.ssh.password ?? "-" : pc5.dim("*** (\u52A0 --show-password \u663E\u793A)")
+          ],
+          [
+            "CPU",
+            snapshot.usage.cpuPercent !== null ? `${snapshot.usage.cpuPercent.toFixed(1)}%` : "-"
+          ],
+          [
+            "\u5185\u5B58",
+            snapshot.usage.memUsedBytes !== null ? `${formatBytes(snapshot.usage.memUsedBytes)} / ${formatBytes(snapshot.usage.memLimitBytes)}` : "-"
+          ],
+          [
+            "\u7CFB\u7EDF\u76D8",
+            snapshot.usage.rootFsUsedBytes !== null ? `${formatBytes(snapshot.usage.rootFsUsedBytes)} / ${formatBytes(snapshot.usage.rootFsTotalBytes)}` : "-"
+          ]
+        ]);
+        if (snapshot.services.length) {
+          process.stdout.write("\n");
+          printTable(
+            ["\u7AEF\u53E3", "\u534F\u8BAE", "\u5916\u90E8\u5730\u5740"],
+            snapshot.services.map((service) => [
+              service.port,
+              service.protocol ?? "-",
+              service.domain
+            ])
+          );
+        }
+      });
+      return 0;
+    })
+  );
+  program.command("create").description("\u521B\u5EFA\u4E00\u4E2A\u6309\u91CF\u8BA1\u8D39\u7684 Pro \u5B9E\u4F8B").requiredOption("--gpu <spec>", "GPU \u89C4\u683C\uFF0C\u53EF\u7528 `autodl gpus` \u67E5\u770B").option("--num <n>", "GPU \u6570\u91CF\uFF081-4\uFF09", "1").option("--image <uuid>", "\u955C\u50CF UUID \u6216\u516C\u5171\u955C\u50CF\u6807\u7B7E", DEFAULT_BASE_IMAGE).option("--cuda <version>", "\u6700\u4F4E CUDA \u7248\u672C\uFF0C\u5982 11.8").option("--region <code...>", "\u4F18\u5148\u5730\u533A\uFF0C\u53EF\u591A\u6B21\u6307\u5B9A").option("--disk <gb>", "\u7CFB\u7EDF\u76D8\u6269\u5BB9 GB\uFF080-500\uFF09", "0").option("--name <name>", "\u5B9E\u4F8B\u540D\u79F0").option("--ttl <duration>", "\u5230\u671F\u81EA\u52A8\u5173\u673A\uFF0C\u5982 2h / 90m\uFF08\u5F3A\u70C8\u5EFA\u8BAE\u8BBE\u7F6E\uFF09").option("--start-command <cmd>", "\u5F00\u673A\u540E\u6267\u884C\u7684\u547D\u4EE4").option("--min-balance <yuan>", "\u4F59\u989D\u4F4E\u4E8E\u8BE5\u503C\u65F6\u62D2\u7EDD\u521B\u5EFA").option("--wait", "\u7B49\u5F85\u5B9E\u4F8B\u8FDB\u5165 running \u72B6\u6001", false).option("--no-stock-check", "\u8DF3\u8FC7\u521B\u5EFA\u524D\u7684 GPU \u5E93\u5B58\u67E5\u8BE2").action(
+    action(async (context, options) => {
+      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 image = findBaseImage(options.image ?? DEFAULT_BASE_IMAGE);
+      const imageUuid = image?.uuid ?? options.image ?? DEFAULT_BASE_IMAGE;
+      const cudaFrom = options.cuda ? parseCudaVersion(options.cuda) : parseCudaVersion(image?.cuda ?? "11.8");
+      const requestedRegions = (options.region ?? []).map(
+        (input) => assertProCreateRegion(input).id
+      );
+      const regions = options.stockCheck === false ? requestedRegions : (await chooseRegions(context.client, spec, requestedRegions)).regions;
+      const ttlSeconds = options.ttl ? parseDuration(options.ttl) : void 0;
+      if (!ttlSeconds) {
+        warn(
+          "\u672A\u8BBE\u7F6E --ttl\uFF1A\u5B9E\u4F8B\u4F1A\u4E00\u76F4\u8BA1\u8D39\u76F4\u5230\u624B\u52A8\u5173\u673A\u3002AutoDL \u6309\u5F00\u673A\u65F6\u957F\u8BA1\u8D39\uFF0C\u4E0E\u662F\u5426\u4F7F\u7528 GPU \u65E0\u5173\u3002"
+        );
+      }
+      await assertBudget(
+        context.client,
+        options.minBalance !== void 0 ? Number(options.minBalance) : void 0
+      );
+      const startCommand = composeStartCommand(ttlSeconds, options.startCommand);
+      const spin = isJson() ? null : spinner2();
+      spin?.start(t("instance.creating"));
+      let uuid;
+      try {
+        uuid = await createInstance(context.client, {
+          gpuSpec: spec.id,
+          gpuNum: Number(options.num),
+          imageUuid,
+          cudaFrom,
+          expandSystemDiskGb: Number(options.disk),
+          ...regions.length ? { regions } : {},
+          ...options.name ? { name: options.name } : {},
+          ...startCommand ? { startCommand } : {}
+        });
+      } catch (err) {
+        spin?.stop("\u521B\u5EFA\u5931\u8D25", 1);
+        throw err;
+      }
+      spin?.stop(`${t("instance.created")}\uFF1A${uuid}`);
+      if (ttlSeconds) {
+        recordTTL({
+          uuid,
+          ...options.name ? { name: options.name } : {},
+          ttlSeconds,
+          inInstanceTimer: true
+        });
+      }
+      let status = "creating";
+      if (options.wait) {
+        const waitSpin = isJson() ? null : spinner2();
+        waitSpin?.start(t("instance.waiting"));
+        status = await waitForRunning(context.client, uuid);
+        waitSpin?.stop(t("instance.ready"));
+      }
+      emit(
+        {
+          uuid,
+          gpuSpec: spec.id,
+          gpuNum: Number(options.num),
+          imageUuid,
+          cudaFrom,
+          regions,
+          ttlSeconds: ttlSeconds ?? null,
+          status
+        },
+        () => {
+          success(`\u5B9E\u4F8B ${pc5.bold(uuid)} \u5DF2\u521B\u5EFA`);
+          if (ttlSeconds) note(`${t("guard.armed")}\uFF1A${formatDuration(ttlSeconds)} \u540E\u81EA\u52A8\u5173\u673A`);
+          note(`\u8FDE\u63A5\uFF1Aautodl ssh ${uuid}`);
+        }
+      );
+      return 0;
+    })
+  );
+  program.command("start <id>").description("\u5F00\u673A").option("--ttl <duration>", "\u5F00\u673A\u540E\u8BBE\u7F6E\u5230\u671F\u81EA\u52A8\u5173\u673A").option("--start-command <cmd>", "\u5F00\u673A\u540E\u6267\u884C\u7684\u547D\u4EE4").option("--wait", "\u7B49\u5F85\u5B9E\u4F8B\u8FDB\u5165 running \u72B6\u6001", false).action(
+    action(
+      async (context, id, options) => {
+        const ttlSeconds = options.ttl ? parseDuration(options.ttl) : void 0;
+        const startCommand = composeStartCommand(ttlSeconds, options.startCommand);
+        note(t("instance.poweringOn"));
+        await powerOnInstance(context.client, id, {
+          ...startCommand ? { startCommand } : {}
+        });
+        let armed = Boolean(ttlSeconds);
+        if (options.wait || ttlSeconds) {
+          const spin = isJson() ? null : spinner2();
+          spin?.start(t("instance.waiting"));
+          await waitForRunning(context.client, id);
+          spin?.stop(t("instance.ready"));
+          if (ttlSeconds) {
+            armed = await armTTLOverSSH(context.client, id, ttlSeconds);
+            if (!armed) warn(t("guard.armFailed"));
+            recordTTL({ uuid: id, ttlSeconds, inInstanceTimer: armed });
+          }
+        }
+        emit(
+          { uuid: id, started: true, ttlSeconds: ttlSeconds ?? null, inInstanceTimer: armed },
+          () => {
+            success(`\u5B9E\u4F8B ${id} \u5DF2\u5F00\u673A`);
+            if (ttlSeconds) note(`${t("guard.armed")}\uFF1A${formatDuration(ttlSeconds)} \u540E\u81EA\u52A8\u5173\u673A`);
+          }
+        );
+        return 0;
+      }
+    )
+  );
+  program.command("stop <id>").description("\u5173\u673A\uFF08\u505C\u6B62\u8BA1\u8D39\uFF0C\u6570\u636E\u4FDD\u7559\uFF09").action(
+    action(async (context, id) => {
+      note(t("instance.poweringOff"));
+      await powerOffInstance(context.client, id);
+      const after = await getInstanceStatus(context.client, id).catch(() => "unknown");
+      const stopped = after !== "running" && after !== "starting";
+      if (stopped) untrackInstance(id);
+      emit({ uuid: id, stopped, status: after }, () => {
+        if (stopped) success(`\u5B9E\u4F8B ${id} \u5DF2\u5173\u673A\uFF0C\u8BA1\u8D39\u5DF2\u505C\u6B62`);
+        else
+          warn(
+            `\u5173\u673A\u6307\u4EE4\u5DF2\u53D1\u9001\uFF0C\u4F46\u5B9E\u4F8B\u72B6\u6001\u4ECD\u4E3A ${after}\u3002\u5B9E\u4F8B\u53EF\u80FD\u4ECD\u5728\u542F\u52A8\u4E2D\uFF0C\u7A0D\u540E\u8BF7\u7528 \`autodl ls\` \u786E\u8BA4\uFF0C\u5FC5\u8981\u65F6\u91CD\u8BD5 \`autodl stop ${id}\`\u3002`
+          );
+      });
+      return stopped ? 0 : 1;
+    })
+  );
+  program.command("rm <id>").alias("release").description("\u91CA\u653E\u5B9E\u4F8B\uFF08\u4E0D\u53EF\u9006\uFF0C\u6570\u636E\u5C06\u88AB\u6C38\u4E45\u6E05\u7A7A\uFF09").option("-y, --yes", "\u8DF3\u8FC7\u786E\u8BA4", false).option("--force", "\u82E5\u5B9E\u4F8B\u4ECD\u5728\u8FD0\u884C\u5219\u5148\u81EA\u52A8\u5173\u673A", false).action(
+    action(async (context, id, options) => {
+      const status = await getInstanceStatus(context.client, id);
+      if (status !== "shutdown") {
+        if (!options.force) {
+          throw new UsageError(`\u5B9E\u4F8B\u5F53\u524D\u72B6\u6001\u4E3A "${status}"\uFF0CAutoDL \u8981\u6C42\u5148\u5173\u673A\u624D\u80FD\u91CA\u653E`, {
+            hint: "\u5148\u8FD0\u884C `autodl stop <id>`\uFF0C\u6216\u52A0 --force \u8BA9\u672C\u547D\u4EE4\u81EA\u52A8\u5173\u673A\u3002"
+          });
+        }
+        if (status !== "shutting_down") {
+          note(t("instance.poweringOff"));
+          await powerOffInstance(context.client, id);
+        }
+        await waitForShutdown(context.client, id, { timeoutMs: 10 * 6e4 });
+      }
+      const confirmed = await confirmDestructive(
+        `${t("instance.confirmRelease")} ${id}`,
+        options.yes
+      );
+      if (!confirmed) {
+        emit({ uuid: id, released: false, cancelled: true }, () => note(t("common.cancelled")));
+        return 0;
+      }
+      await releaseInstance(context.client, id);
+      untrackInstance(id);
+      emit({ uuid: id, released: true }, () => success(`${t("instance.released")}\uFF1A${id}`));
+      return 0;
+    })
+  );
+}
+
+// src/commands/mcp.ts
+function registerMcpCommand(program) {
+  program.command("mcp").description("\u4EE5 stdio MCP server \u65B9\u5F0F\u8FD0\u884C\uFF0C\u4F9B Claude Code / Cursor / Cline \u7B49 agent \u8C03\u7528").action(async (_options, command) => {
+    const globals = globalsOf(command);
+    try {
+      await startMcpServer({
+        ...globals.token ? { token: globals.token } : {},
+        ...globals.baseUrl ? { baseUrl: globals.baseUrl } : {}
+      });
+    } catch (err) {
+      const error = toAutoDLError(err);
+      process.stderr.write(`${error.message}
+`);
+      if (error.hint) process.stderr.write(`${error.hint}
+`);
+      process.exitCode = error.exitCode;
+    }
+  });
+}
+
+// src/commands/run.ts
+function registerRunCommand(program) {
+  program.command("run <command...>").description("\u4E00\u952E\u5DE5\u4F5C\u6D41\uFF1A\u5EFA\u5B9E\u4F8B \u2192 \u540C\u6B65\u4EE3\u7801 \u2192 \u8FDC\u7A0B\u6267\u884C \u2192 \u56DE\u4F20\u4EA7\u7269 \u2192 \u81EA\u52A8\u5173\u673A").requiredOption("--gpu <spec>", "GPU \u89C4\u683C\uFF0C\u53EF\u7528 `autodl gpus` \u67E5\u770B").option("--num <n>", "GPU \u6570\u91CF\uFF081-4\uFF09", "1").option("--image <uuid>", "\u955C\u50CF UUID \u6216\u516C\u5171\u955C\u50CF\u6807\u7B7E").option("--cuda <version>", "\u6700\u4F4E CUDA \u7248\u672C\uFF0C\u5982 11.8").option("--region <code...>", "\u4F18\u5148\u5730\u533A").option("--disk <gb>", "\u7CFB\u7EDF\u76D8\u6269\u5BB9 GB", "0").option("--name <name>", "\u5B9E\u4F8B\u540D\u79F0").option("--ttl <duration>", "\u5230\u671F\u81EA\u52A8\u5173\u673A\uFF08\u515C\u5E95\u4FDD\u62A4\uFF0C\u9ED8\u8BA4 4h\uFF09", "4h").option("--sync <dir>", "\u6267\u884C\u524D\u4E0A\u4F20\u7684\u672C\u5730\u76EE\u5F55").option("--workdir <dir>", "\u8FDC\u7A0B\u5DE5\u4F5C\u76EE\u5F55\uFF08\u6570\u636E\u76D8\uFF09", "/root/autodl-tmp/autodl-cli").option("--pull <remote>", "\u6267\u884C\u540E\u56DE\u4F20\u7684\u8FDC\u7A0B\u8DEF\u5F84").option("--pull-to <local>", "\u56DE\u4F20\u4EA7\u7269\u7684\u672C\u5730\u76EE\u5F55", "./autodl-output").option("--on-finish <action>", "\u7ED3\u675F\u540E\u52A8\u4F5C\uFF1Apoweroff / release / keep", "poweroff").option("--timeout <duration>", "\u8FDC\u7A0B\u547D\u4EE4\u8D85\u65F6\u65F6\u95F4").option("--min-balance <yuan>", "\u4F59\u989D\u4F4E\u4E8E\u8BE5\u503C\u65F6\u62D2\u7EDD\u521B\u5EFA").option("--env <key=value...>", "\u6CE8\u5165\u73AF\u5883\u53D8\u91CF").action(
+    action(async (context, commandParts, options) => {
+      const command = commandParts.join(" ");
+      const env = {};
+      for (const pair of options.env ?? []) {
+        const index = pair.indexOf("=");
+        if (index > 0) env[pair.slice(0, index)] = pair.slice(index + 1);
+      }
+      if (!["poweroff", "release", "keep"].includes(options.onFinish)) {
+        warn(`\u672A\u77E5\u7684 --on-finish "${options.onFinish}"\uFF0C\u6309 poweroff \u5904\u7406`);
+      }
+      const controller = new AbortController();
+      let interrupted = false;
+      const onSigint = () => {
+        if (interrupted) return;
+        interrupted = true;
+        warn("\u6536\u5230\u4E2D\u65AD\u4FE1\u53F7\uFF0C\u6B63\u5728\u5B89\u5168\u6536\u5C3E\uFF08\u5B9E\u4F8B\u5C06\u88AB\u5173\u673A\uFF09\u2026");
+        controller.abort();
+      };
+      process.on("SIGINT", onSigint);
+      process.on("SIGTERM", onSigint);
+      try {
+        const result = await runWorkflow(context.client, {
+          command,
+          gpu: options.gpu,
+          gpuNum: Number(options.num),
+          ...options.image ? { image: options.image } : {},
+          ...options.cuda ? { cudaFrom: options.cuda } : {},
+          ...options.region ? { regions: options.region } : {},
+          diskGb: Number(options.disk),
+          ...options.name ? { name: options.name } : {},
+          ttlSeconds: parseDuration(options.ttl),
+          ...options.sync ? { sync: options.sync } : {},
+          ...options.workdir ? { workdir: options.workdir } : {},
+          ...options.pull ? { pullFrom: options.pull } : {},
+          ...options.pullTo ? { pullTo: options.pullTo } : {},
+          onFinish: ["poweroff", "release", "keep"].includes(options.onFinish) ? options.onFinish : "poweroff",
+          ...options.timeout ? { commandTimeoutMs: parseDuration(options.timeout) * 1e3 } : {},
+          ...options.minBalance !== void 0 ? { minBalanceYuan: Number(options.minBalance) } : {},
+          ...Object.keys(env).length ? { env } : {},
+          signal: controller.signal
+        });
+        emit(result, () => {
+          note(`\u7528\u65F6 ${formatDuration(Math.round(result.durationMs / 1e3))}`);
+          if (result.exitCode === 0) success("\u8FDC\u7A0B\u547D\u4EE4\u6267\u884C\u6210\u529F");
+          else warn(`\u8FDC\u7A0B\u547D\u4EE4\u9000\u51FA\u7801 ${result.exitCode}`);
+        });
+        return result.exitCode ?? 1;
+      } finally {
+        process.off("SIGINT", onSigint);
+        process.off("SIGTERM", onSigint);
+      }
+    })
+  );
+}
+
+// src/commands/ssh.ts
+import pc6 from "picocolors";
+function registerSSHCommands(program) {
+  program.command("ssh <id>").description("\u4EA4\u4E92\u5F0F SSH \u767B\u5F55\u5B9E\u4F8B").option("--start", "\u5B9E\u4F8B\u672A\u8FD0\u884C\u65F6\u81EA\u52A8\u5F00\u673A", false).option("--print", "\u53EA\u6253\u5370\u8FDE\u63A5\u4FE1\u606F\uFF0C\u4E0D\u5EFA\u7ACB\u8FDE\u63A5", false).allowUnknownOption().action(
+    action(async (context, id, options, command) => {
+      if (options.print) {
+        const creds = await getCredentials(context.client, id, { autoStart: options.start });
+        emit(creds, () => {
+          printKeyValues([
+            ["\u547D\u4EE4", `ssh -p ${creds.port} ${creds.user}@${creds.host}`],
+            ["\u5BC6\u7801", creds.password]
+          ]);
+        });
+        return 0;
+      }
+      const extraArgs = command.args.slice(1);
+      return connectInteractive(context.client, id, {
+        autoStart: options.start,
+        extraArgs
+      });
+    })
+  );
+  program.command("exec <id> <command...>").description("\u5728\u5B9E\u4F8B\u4E0A\u6267\u884C\u547D\u4EE4\uFF0C\u6D41\u5F0F\u56DE\u4F20\u8F93\u51FA\uFF0C\u900F\u4F20\u8FDC\u7A0B\u9000\u51FA\u7801").option("--start", "\u5B9E\u4F8B\u672A\u8FD0\u884C\u65F6\u81EA\u52A8\u5F00\u673A", false).option("--cwd <dir>", "\u8FDC\u7A0B\u5DE5\u4F5C\u76EE\u5F55").option("--timeout <duration>", "\u547D\u4EE4\u8D85\u65F6\u65F6\u95F4\uFF0C\u5982 30m").option("--env <key=value...>", "\u6CE8\u5165\u73AF\u5883\u53D8\u91CF").option("--pty", "\u5206\u914D\u4F2A\u7EC8\u7AEF\uFF08\u9700\u8981 isatty \u7684\u7A0B\u5E8F\u7528\u5F97\u4E0A\uFF09", false).action(
+    action(
+      async (context, id, commandParts, options) => {
+        const remoteCommand = commandParts.join(" ");
+        const env = {};
+        for (const pair of options.env ?? []) {
+          const index = pair.indexOf("=");
+          if (index > 0) env[pair.slice(0, index)] = pair.slice(index + 1);
+        }
+        const result = await execCommand(context.client, id, remoteCommand, {
+          autoStart: options.start,
+          capture: true,
+          // Humans expect `autodl exec box "cat f" > out.txt` to work, so remote
+          // stdout goes to stdout. In --json mode (and under MCP, which sets it)
+          // stdout is reserved for the payload, so it is diverted to stderr.
+          stdout: isJson() ? process.stderr : process.stdout,
+          stderr: process.stderr,
+          pty: options.pty,
+          ...options.cwd ? { cwd: options.cwd } : {},
+          ...Object.keys(env).length ? { env } : {},
+          ...options.timeout ? { timeoutMs: parseDuration(options.timeout) * 1e3 } : {}
+        });
+        emit(
+          {
+            uuid: id,
+            command: remoteCommand,
+            exitCode: result.exitCode,
+            signal: result.signal,
+            stdout: result.stdout,
+            stderr: result.stderr
+          },
+          () => {
+          }
+        );
+        return result.exitCode ?? 1;
+      }
+    )
+  );
+  program.command("push <id> <local> [remote]").description("\u4E0A\u4F20\u6587\u4EF6\u6216\u76EE\u5F55\u5230\u5B9E\u4F8B\uFF08SFTP\uFF09").option("--start", "\u5B9E\u4F8B\u672A\u8FD0\u884C\u65F6\u81EA\u52A8\u5F00\u673A", false).option("--ignore <pattern...>", "\u989D\u5916\u5FFD\u7565\u7684\u8DEF\u5F84\u6A21\u5F0F").action(
+    action(
+      async (context, id, local, remote, options) => {
+        const target = remote ?? "/root/autodl-tmp/autodl-cli";
+        const summary = await push(context.client, id, local, target, {
+          autoStart: options.start,
+          ...options.ignore ? { ignore: options.ignore } : {},
+          onProgress: ({ file, index, total }) => note(pc6.dim(`\u2191 [${index}/${total}] ${file}`))
+        });
+        emit(
+          { uuid: id, local, remote: target, ...summary },
+          () => success(`\u5DF2\u4E0A\u4F20 ${summary.files} \u4E2A\u6587\u4EF6\uFF08${formatBytes(summary.bytes)}\uFF09\u5230 ${target}`)
+        );
+        return 0;
+      }
+    )
+  );
+  program.command("pull <id> <remote> [local]").description("\u4ECE\u5B9E\u4F8B\u4E0B\u8F7D\u6587\u4EF6\u6216\u76EE\u5F55\uFF08SFTP\uFF09").option("--start", "\u5B9E\u4F8B\u672A\u8FD0\u884C\u65F6\u81EA\u52A8\u5F00\u673A", false).action(
+    action(
+      async (context, id, remote, local, options) => {
+        const target = local ?? "./autodl-output";
+        const summary = await pull(context.client, id, remote, target, {
+          autoStart: options.start,
+          onProgress: ({ file, index, total }) => note(pc6.dim(`\u2193 [${index}/${total}] ${file}`))
+        });
+        emit(
+          { uuid: id, remote, local: target, ...summary },
+          () => success(`\u5DF2\u4E0B\u8F7D ${summary.files} \u4E2A\u6587\u4EF6\uFF08${formatBytes(summary.bytes)}\uFF09\u5230 ${target}`)
+        );
+        return 0;
+      }
+    )
+  );
+}
+
+// src/commands/stock.ts
+import pc7 from "picocolors";
+function registerStockCommand(program) {
+  program.command("stock").description("\u67E5\u8BE2\u5404\u5730\u533A GPU \u5B9E\u65F6\u5E93\u5B58\uFF08\u521B\u5EFA\u5B9E\u4F8B\u524D\u770B\u54EA\u91CC\u6709\u8D27\uFF09").option("--gpu <spec>", "\u53EA\u770B\u67D0\u4E2A GPU \u89C4\u683C\uFF0C\u53EF\u7528 `autodl gpus` \u67E5\u770B").option("--region <code...>", "\u53EA\u770B\u6307\u5B9A\u5730\u533A\uFF0C\u9ED8\u8BA4\u67E5\u5168\u90E8").option("--all", "\u663E\u793A\u65E0\u8D27\u7684\u5730\u533A\u4E0E\u578B\u53F7", false).action(
+    action(
+      async (context, options) => {
+        const spec = options.gpu ? resolveGpuSpec(options.gpu) : void 0;
+        if (options.gpu && !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 { snapshots, failures } = await getStockByRegion(context.client, {
+          ...options.region?.length ? { regions: options.region } : {},
+          ...spec ? { gpuNames: [spec.stockName] } : {}
+        });
+        const rentable = new Map(GPU_SPECS.map((s) => [s.stockName, s]));
+        const rows = snapshots.flatMap(
+          (snapshot) => snapshot.entries.filter((entry) => options.all || entry.idle > 0).map((entry) => ({
+            regionId: snapshot.regionId,
+            regionName: snapshot.regionName,
+            gpuName: entry.gpuName,
+            gpuSpec: rentable.get(entry.gpuName)?.id ?? null,
+            // Only two regions accept a Pro instance; the rest are ESD-only.
+            proCreate: resolveRegion(snapshot.regionId)?.proCreate ?? false,
+            idle: entry.idle,
+            total: entry.total
+          }))
+        );
+        rows.sort((a, b) => b.idle - a.idle);
+        emit({ rows, failures }, () => {
+          if (rows.length === 0) {
+            note(
+              spec ? `${spec.displayName} \u5F53\u524D\u5728\u67E5\u8BE2\u7684\u5730\u533A\u5747\u65E0\u7A7A\u95F2` : "\u67E5\u8BE2\u8303\u56F4\u5185\u6CA1\u6709\u7A7A\u95F2 GPU"
+            );
+          } else {
+            printTable(
+              ["\u5730\u533A", "\u53EF\u5EFAPro", "GPU", "\u53EF\u79DF\u89C4\u683C", "\u7A7A\u95F2", "\u603B\u6570"],
+              rows.map((row) => [
+                row.regionName,
+                row.proCreate ? pc7.green("\u662F") : pc7.dim("\u5426"),
+                row.gpuName,
+                row.gpuSpec ? pc7.green(row.gpuSpec) : pc7.dim("\u2014"),
+                row.idle === 0 ? pc7.dim("0") : pc7.bold(String(row.idle)),
+                row.total
+              ])
+            );
+            note(
+              pc7.dim(
+                `\u300C\u53EF\u5EFAPro\u300D\u53EA\u6709 ${PRO_CREATE_REGIONS.map((r) => r.displayName).join(" / ")} \u4E3A\u300C\u662F\u300D\uFF0C\u5176\u4F59\u5730\u533A\u4EC5\u7528\u4E8E\u5F39\u6027\u90E8\u7F72\uFF0C\u5199\u8FDB --region \u4F1A\u88AB\u62D2\u7EDD\u3002`
+              )
+            );
+            note(
+              pc7.dim(
+                "\u300C\u53EF\u79DF\u89C4\u683C\u300D\u4E3A\u7A7A\u8868\u793A\u8BE5\u578B\u53F7\u65E0\u6CD5\u901A\u8FC7\u5B98\u65B9\u5F00\u653E API \u521B\u5EFA\uFF08\u53EA\u80FD\u5F00 Pro \u5B9E\u4F8B\u7684 7 \u4E2A\u89C4\u683C\uFF09\u3002"
+              )
+            );
+            note(
+              pc7.yellow(
+                "\u6CE8\u610F\uFF1A\u8FD9\u4E9B\u6570\u5B57\u6765\u81EA\u300C\u5F39\u6027\u90E8\u7F72 GPU \u5E93\u5B58\u300D\uFF0C\u4E0D\u4EE3\u8868 Pro \u5B9E\u4F8B\u7684\u53EF\u7528\u91CF\u2014\u2014\u5B9E\u6D4B\u51FA\u73B0\u8FC7\u5E93\u5B58\u663E\u793A 140 \u5F20\u7A7A\u95F2\u3001Pro \u521B\u5EFA\u5374\u63D0\u793A\u6682\u65E0\u5E93\u5B58\u7684\u60C5\u51B5\u3002\u4EC5\u4F9B\u53C2\u8003\uFF0C\u4E0D\u8981\u636E\u6B64\u5224\u65AD\u521B\u5EFA\u4E00\u5B9A\u5931\u8D25\u3002"
+              )
+            );
+            note(pc7.dim("\u521B\u5EFA\u5B9E\u4F8B\u65F6\u4E0D\u6307\u5B9A --region\uFF0C\u7531 AutoDL \u81EA\u884C\u8C03\u5EA6\uFF0C\u6210\u529F\u7387\u66F4\u9AD8\u3002"));
+          }
+          for (const failure of failures) warn(`${failure.regionId} \u67E5\u8BE2\u5931\u8D25\uFF1A${failure.reason}`);
+        });
+        return 0;
+      },
+      { sweep: false }
+    )
+  );
+}
+
+// src/cli.ts
+function buildProgram() {
+  const program = new Command();
+  program.name("autodl").description(
+    [
+      "AutoDL \u5B9E\u4F8B\u7BA1\u7406\u547D\u4EE4\u884C\u5DE5\u5177\uFF08\u975E\u5B98\u65B9\uFF09\u3002",
+      "",
+      "\u9762\u5411\u4EBA\u548C agent \u4E24\u79CD\u4F7F\u7528\u8005\uFF1A\u6240\u6709\u547D\u4EE4\u90FD\u652F\u6301 --json \u8F93\u51FA\u4E0E\u7A33\u5B9A\u9000\u51FA\u7801\uFF0C",
+      "`autodl mcp` \u53EF\u76F4\u63A5\u4F5C\u4E3A MCP server \u63A5\u5165 Claude Code / Cursor / Cline\u3002"
+    ].join("\n")
+  ).version(VERSION, "-v, --version").option("--token <token>", "AutoDL \u5F00\u53D1\u8005 Token\uFF08\u4F18\u5148\u7EA7\u9AD8\u4E8E\u73AF\u5883\u53D8\u91CF\u4E0E\u914D\u7F6E\u6587\u4EF6\uFF09").option("--base-url <url>", "API \u57FA\u5730\u5740\uFF0C\u9ED8\u8BA4 https://api.autodl.com").option("--json", "\u4EE5 JSON \u8F93\u51FA\u5230 stdout\uFF08\u4EBA\u7C7B\u53EF\u8BFB\u4FE1\u606F\u8D70 stderr\uFF09", false).option("--no-color", "\u7981\u7528\u5F69\u8272\u8F93\u51FA").option("--verbose", "\u8F93\u51FA\u8C03\u8BD5\u4FE1\u606F", false).option("--lang <lang>", "\u8F93\u51FA\u8BED\u8A00\uFF1Azh / en").option("--no-sweep", "\u8DF3\u8FC7\u542F\u52A8\u65F6\u7684 TTL \u8D85\u65F6\u5B9E\u4F8B\u81EA\u52A8\u6E05\u7406").showHelpAfterError("\uFF08\u8FD0\u884C `autodl --help` \u67E5\u770B\u7528\u6CD5\uFF09");
+  registerAuthCommands(program);
+  registerAccountCommands(program);
+  registerInstanceCommands(program);
+  registerSSHCommands(program);
+  registerRunCommand(program);
+  registerDeployCommand(program);
+  registerGuardCommands(program);
+  registerCatalogCommands(program);
+  registerStockCommand(program);
+  registerTuiCommand(program);
+  registerMcpCommand(program);
+  program.addHelpText(
+    "after",
+    [
+      "",
+      "\u9000\u51FA\u7801\uFF1A",
+      "  0 \u6210\u529F   1 \u901A\u7528\u9519\u8BEF   2 \u53C2\u6570\u9519\u8BEF   3 Token \u65E0\u6548   4 \u8D44\u6E90\u4E0D\u5B58\u5728",
+      "  5 \u4F59\u989D\u4E0D\u8DB3/\u88AB\u62A4\u680F\u62E6\u622A   6 GPU \u65E0\u5E93\u5B58   7 \u8D85\u65F6   8 SSH \u5931\u8D25",
+      "",
+      "\u793A\u4F8B\uFF1A",
+      "  autodl login                                    \u914D\u7F6E\u5F00\u53D1\u8005 Token",
+      "  autodl create --gpu 4090 --ttl 2h --wait        \u521B\u5EFA\u5B9E\u4F8B\u5E76\u7B49\u5F85\u5C31\u7EEA",
+      "  autodl exec pro-xxx 'nvidia-smi'                \u8FDC\u7A0B\u6267\u884C\u547D\u4EE4",
+      "  autodl run 'python train.py' --gpu 4090 \\",
+      "    --sync ./ --pull /root/autodl-tmp/autodl-cli/out   \u8DD1\u5B8C\u81EA\u52A8\u5173\u673A",
+      "  autodl ls --json | jq '.data[].uuid'            \u4F9B\u811A\u672C\u4E0E agent \u6D88\u8D39",
+      "",
+      "\u63A5\u5165 agent\uFF08Claude Code\uFF09\uFF1A",
+      "  claude mcp add autodl -- npx -y @minato-aqukin/autodl-cli mcp"
+    ].join("\n")
+  );
+  return program;
+}
+function shouldLaunchBareTui(argv) {
+  const args = argv.slice(2);
+  if (args.length > 0) return false;
+  if (!process.stdout.isTTY || !process.stdin.isTTY) return false;
+  return true;
+}
+async function main(argv = process.argv) {
+  if (shouldLaunchBareTui(argv)) {
+    try {
+      const { launchTui } = await import("./tui-AARJCHRA.js");
+      await launchTui({});
+      return;
+    } catch (err) {
+      const error = toAutoDLError(err);
+      emitError(error);
+      process.exitCode = error.exitCode;
+      return;
+    }
+  }
+  const program = buildProgram();
+  try {
+    await program.parseAsync(argv);
+  } catch (err) {
+    const asCommanderError = err;
+    if (typeof asCommanderError?.code === "string" && asCommanderError.code.startsWith("commander.")) {
+      process.exitCode = asCommanderError.exitCode ?? ExitCode.OK;
+      return;
+    }
+    const error = toAutoDLError(err);
+    emitError(error);
+    process.exitCode = error.exitCode;
+  }
+}
+main().catch((err) => {
+  const error = toAutoDLError(err);
+  emitError(error);
+  process.exitCode = error.exitCode;
+});
+export {
+  buildProgram,
+  main,
+  shouldLaunchBareTui
+};
+//# sourceMappingURL=cli.js.map