@minato-aqukin/autodl-cli 0.1.0

package/dist/chunk-6QR4ZYQR.js

@@ -0,0 +1,1432 @@
+#!/usr/bin/env node
+import { createRequire as __nodeCreateRequire } from "node:module";
+const require = __nodeCreateRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/core/errors.ts
+var ExitCode = {
+  OK: 0,
+  GENERIC: 1,
+  USAGE: 2,
+  AUTH: 3,
+  NOT_FOUND: 4,
+  BUDGET: 5,
+  NO_STOCK: 6,
+  TIMEOUT: 7,
+  SSH: 8
+};
+var AutoDLError = class extends Error {
+  code;
+  exitCode;
+  hint;
+  requestId;
+  details;
+  constructor(message, options2 = {}) {
+    super(message, options2.cause !== void 0 ? { cause: options2.cause } : void 0);
+    this.name = "AutoDLError";
+    this.code = options2.code ?? "GENERIC";
+    this.exitCode = options2.exitCode ?? ExitCode.GENERIC;
+    this.hint = options2.hint;
+    this.requestId = options2.requestId;
+    this.details = options2.details;
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      ...this.hint ? { hint: this.hint } : {},
+      ...this.requestId ? { requestId: this.requestId } : {}
+    };
+  }
+};
+var AuthError = class extends AutoDLError {
+  constructor(message, options2 = {}) {
+    super(message, { code: "AUTH_INVALID", exitCode: ExitCode.AUTH, ...options2 });
+    this.name = "AuthError";
+  }
+};
+var NotFoundError = class extends AutoDLError {
+  constructor(message, options2 = {}) {
+    super(message, { code: "NOT_FOUND", exitCode: ExitCode.NOT_FOUND, ...options2 });
+    this.name = "NotFoundError";
+  }
+};
+var UsageError = class extends AutoDLError {
+  constructor(message, options2 = {}) {
+    super(message, { code: "USAGE", exitCode: ExitCode.USAGE, ...options2 });
+    this.name = "UsageError";
+  }
+};
+var BudgetError = class extends AutoDLError {
+  constructor(message, options2 = {}) {
+    super(message, { code: "GUARD_BLOCKED", exitCode: ExitCode.BUDGET, ...options2 });
+    this.name = "BudgetError";
+  }
+};
+var NoStockError = class extends AutoDLError {
+  constructor(message, options2 = {}) {
+    super(message, { code: "NO_STOCK", exitCode: ExitCode.NO_STOCK, ...options2 });
+    this.name = "NoStockError";
+  }
+};
+var TimeoutError = class extends AutoDLError {
+  constructor(message, options2 = {}) {
+    super(message, { code: "TIMEOUT", exitCode: ExitCode.TIMEOUT, ...options2 });
+    this.name = "TimeoutError";
+  }
+};
+var SSHError = class extends AutoDLError {
+  constructor(message, options2 = {}) {
+    super(message, { code: "SSH_FAILED", exitCode: ExitCode.SSH, ...options2 });
+    this.name = "SSHError";
+  }
+};
+function toAutoDLError(err) {
+  if (err instanceof AutoDLError) return err;
+  if (err instanceof Error) {
+    return new AutoDLError(err.message, { cause: err });
+  }
+  return new AutoDLError(String(err));
+}
+function isAuthError(err) {
+  return err instanceof AutoDLError && (err.code === "AUTH_INVALID" || err.code === "AUTH_MISSING");
+}
+
+// src/config/store.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+function configDir() {
+  const override = process.env.AUTODL_CONFIG_DIR;
+  if (override) return override;
+  const xdg = process.env.XDG_CONFIG_HOME;
+  return join(xdg?.trim() ? xdg : join(homedir(), ".config"), "autodl-cli");
+}
+var configPath = () => join(configDir(), "config.json");
+function readConfig() {
+  const file = configPath();
+  if (!existsSync(file)) return {};
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfig(config) {
+  const file = configPath();
+  mkdirSync(dirname(file), { recursive: true, mode: 448 });
+  writeFileSync(file, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+  chmodSync(file, 384);
+}
+function updateConfig(patch) {
+  const next = { ...readConfig(), ...patch };
+  writeConfig(next);
+  return next;
+}
+function clearToken() {
+  const config = readConfig();
+  delete config.token;
+  if (Object.keys(config).length === 0) {
+    if (existsSync(configPath())) rmSync(configPath());
+    return;
+  }
+  writeConfig(config);
+}
+function resolveToken(explicit) {
+  if (explicit?.trim()) return { token: explicit.trim(), source: "flag" };
+  const fromEnv = process.env.AUTODL_TOKEN;
+  if (fromEnv?.trim()) return { token: fromEnv.trim(), source: "env" };
+  const fromConfig = readConfig().token;
+  if (fromConfig?.trim()) return { token: fromConfig.trim(), source: "config" };
+  throw new AuthError("\u672A\u914D\u7F6E AutoDL \u5F00\u53D1\u8005 Token", {
+    code: "AUTH_MISSING",
+    hint: "\u8FD0\u884C `autodl login` \u4EA4\u4E92\u5199\u5165\uFF0C\u6216\u8BBE\u7F6E AUTODL_TOKEN \u73AF\u5883\u53D8\u91CF\u3002Token \u4F4D\u7F6E\uFF1AAutoDL \u63A7\u5236\u53F0 \u2192 \u8BBE\u7F6E \u2192 \u5F00\u53D1\u8005 Token\uFF08\u9700\u5148\u5B8C\u6210\u5B9E\u540D\u8BA4\u8BC1\uFF09\u3002"
+  });
+}
+function tryResolveToken(explicit) {
+  try {
+    return resolveToken(explicit);
+  } catch {
+    return void 0;
+  }
+}
+function resolveBaseUrl(explicit) {
+  return explicit ?? process.env.AUTODL_BASE_URL ?? readConfig().baseUrl;
+}
+
+// src/core/client.ts
+import { Buffer as Buffer2 } from "buffer";
+import { request as httpsRequest } from "https";
+var DEFAULT_BASE_URL = "https://api.autodl.com";
+function redactToken(token) {
+  if (token.length <= 8) return "****";
+  return `${token.slice(0, 4)}\u2026${token.slice(-4)}`;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function backoffDelay(attempt, baseMs) {
+  const base = Math.min(baseMs * 2 ** attempt, 15e3);
+  return Math.round(base * (0.5 + Math.random() * 0.5));
+}
+function isRetriableStatus(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+var getBodyFallback = /* @__PURE__ */ new Set();
+var AutoDLClient = class {
+  token;
+  baseUrl;
+  timeoutMs;
+  maxRetries;
+  retryBaseDelayMs;
+  onDebug;
+  fetchImpl;
+  constructor(options2) {
+    if (!options2.token) {
+      throw new AuthError("\u672A\u914D\u7F6E AutoDL \u5F00\u53D1\u8005 Token", {
+        code: "AUTH_MISSING",
+        hint: "\u8FD0\u884C `autodl login`\uFF0C\u6216\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF AUTODL_TOKEN\u3002Token \u5728 AutoDL \u63A7\u5236\u53F0 \u2192 \u8BBE\u7F6E \u2192 \u5F00\u53D1\u8005 Token \u83B7\u53D6\u3002"
+      });
+    }
+    this.token = options2.token;
+    this.baseUrl = (options2.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeoutMs = options2.timeoutMs ?? 3e4;
+    this.maxRetries = options2.maxRetries ?? 4;
+    this.retryBaseDelayMs = options2.retryBaseDelayMs ?? 1e3;
+    this.onDebug = options2.onDebug;
+    this.fetchImpl = options2.fetchImpl ?? globalThis.fetch;
+  }
+  get maskedToken() {
+    return redactToken(this.token);
+  }
+  async get(path, body, extra) {
+    return this.request({ method: "GET", path, body, ...extra });
+  }
+  async post(path, body, extra) {
+    return this.request({ method: "POST", path, body, ...extra });
+  }
+  async put(path, body, extra) {
+    return this.request({ method: "PUT", path, body, ...extra });
+  }
+  async delete(path, body, extra) {
+    return this.request({ method: "DELETE", path, body, ...extra });
+  }
+  async request(options2) {
+    const retries = options2.maxRetries ?? this.maxRetries;
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        return await this.attempt(options2);
+      } catch (err) {
+        lastError = err;
+        const retriable = err instanceof AutoDLError && err.details?.retriable === true;
+        if (!retriable || attempt === retries) break;
+        const delay2 = backoffDelay(attempt, this.retryBaseDelayMs);
+        this.debug(`\u91CD\u8BD5 ${options2.method} ${options2.path}\uFF08\u7B2C ${attempt + 1} \u6B21\uFF0C${delay2}ms \u540E\uFF09`);
+        await sleep(delay2);
+      }
+    }
+    throw lastError;
+  }
+  debug(message) {
+    this.onDebug?.(message);
+  }
+  async attempt(options2) {
+    const { method, path, body } = options2;
+    const timeoutMs = options2.timeoutMs ?? this.timeoutMs;
+    const useGetBody = method === "GET" && getBodyFallback.has(path);
+    let envelope;
+    if (useGetBody) {
+      envelope = await this.rawGetWithBody(path, body ?? {}, timeoutMs);
+    } else {
+      envelope = await this.fetchJson(method, path, body, timeoutMs);
+    }
+    if (envelope.code === "Success") {
+      return envelope.data;
+    }
+    if (method === "GET" && !useGetBody && looksLikeMissingParam(envelope.msg)) {
+      getBodyFallback.add(path);
+      this.debug(`${path} \u9700\u8981 GET \u643A\u5E26 body\uFF0C\u5207\u6362\u4F20\u8F93\u65B9\u5F0F\u540E\u91CD\u8BD5`);
+      const retried = await this.rawGetWithBody(path, body ?? {}, timeoutMs);
+      if (retried.code === "Success") return retried.data;
+      throw mapEnvelopeError(retried.code, retried.msg, retried.request_id);
+    }
+    throw mapEnvelopeError(envelope.code, envelope.msg, envelope.request_id);
+  }
+  async fetchJson(method, path, body, timeoutMs) {
+    const url = new URL(this.baseUrl + path);
+    let payload;
+    if (method === "GET") {
+      for (const [key, value] of Object.entries(body ?? {})) {
+        if (value === void 0 || value === null) continue;
+        url.searchParams.set(
+          key,
+          typeof value === "object" ? JSON.stringify(value) : String(value)
+        );
+      }
+    } else if (body !== void 0) {
+      payload = JSON.stringify(body);
+    }
+    this.debug(`${method} ${url.pathname}${url.search} token=${this.maskedToken}`);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let response;
+    try {
+      response = await this.fetchImpl(url, {
+        method,
+        headers: {
+          Authorization: this.token,
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          "User-Agent": "autodl-cli"
+        },
+        ...payload !== void 0 ? { body: payload } : {},
+        signal: controller.signal
+      });
+    } catch (err) {
+      if (controller.signal.aborted) {
+        throw new TimeoutError(`\u8BF7\u6C42\u8D85\u65F6\uFF1A${method} ${path}`, {
+          details: { retriable: true },
+          cause: err
+        });
+      }
+      throw new AutoDLError(`\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25\uFF1A${method} ${path}`, {
+        code: "NETWORK",
+        details: { retriable: true },
+        cause: err
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    return this.readEnvelope(response.status, await response.text(), method, path);
+  }
+  /** GET with a JSON body — legal HTTP/1.1, but fetch refuses, so drop to node:https. */
+  rawGetWithBody(path, body, timeoutMs) {
+    const url = new URL(this.baseUrl + path);
+    const payload = Buffer2.from(JSON.stringify(body));
+    return new Promise((resolve, reject) => {
+      const req = httpsRequest(
+        {
+          hostname: url.hostname,
+          port: url.port || 443,
+          path: url.pathname + url.search,
+          method: "GET",
+          headers: {
+            Authorization: this.token,
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "User-Agent": "autodl-cli",
+            "Content-Length": payload.byteLength
+          },
+          timeout: timeoutMs
+        },
+        (res) => {
+          const chunks = [];
+          res.on("data", (chunk) => chunks.push(chunk));
+          res.on("end", () => {
+            try {
+              resolve(
+                this.readEnvelope(
+                  res.statusCode ?? 0,
+                  Buffer2.concat(chunks).toString("utf8"),
+                  "GET",
+                  path
+                )
+              );
+            } catch (err) {
+              reject(err);
+            }
+          });
+        }
+      );
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new TimeoutError(`\u8BF7\u6C42\u8D85\u65F6\uFF1AGET ${path}`, { details: { retriable: true } }));
+      });
+      req.on(
+        "error",
+        (err) => reject(
+          new AutoDLError(`\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25\uFF1AGET ${path}`, {
+            code: "NETWORK",
+            details: { retriable: true },
+            cause: err
+          })
+        )
+      );
+      req.end(payload);
+    });
+  }
+  readEnvelope(status, text, method, path) {
+    if (status === 401 || status === 403) {
+      throw new AuthError(`Token \u65E0\u6548\u6216\u5DF2\u5931\u6548\uFF08HTTP ${status}\uFF09`, {
+        hint: "\u91CD\u65B0\u8FD0\u884C `autodl login` \u5199\u5165\u65B0\u7684\u5F00\u53D1\u8005 Token\u3002"
+      });
+    }
+    if (isRetriableStatus(status)) {
+      throw new AutoDLError(`AutoDL \u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528\uFF08HTTP ${status}\uFF09\uFF1A${method} ${path}`, {
+        code: "API_ERROR",
+        details: { retriable: true, status }
+      });
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch (err) {
+      throw new AutoDLError(`\u65E0\u6CD5\u89E3\u6790 AutoDL \u54CD\u5E94\uFF08HTTP ${status}\uFF09`, {
+        code: "API_ERROR",
+        details: { status, snippet: text.slice(0, 200) },
+        cause: err
+      });
+    }
+    if (status >= 400 && parsed.code === void 0) {
+      throw new AutoDLError(`AutoDL \u8FD4\u56DE HTTP ${status}\uFF1A${method} ${path}`, {
+        code: "API_ERROR",
+        details: { status }
+      });
+    }
+    return parsed;
+  }
+};
+function looksLikeMissingParam(msg) {
+  const m = (msg ?? "").toLowerCase();
+  return m.includes("param") || m.includes("bind") || m.includes("required") || msg.includes("\u53C2\u6570") || msg.includes("\u5FC5\u586B");
+}
+function mapEnvelopeError(code, msg, requestId) {
+  const text = `${code} ${msg}`;
+  const lower = text.toLowerCase();
+  const message = msg?.trim() ? msg.trim() : `AutoDL \u8FD4\u56DE\u9519\u8BEF\uFF1A${code}`;
+  const opts = { requestId, details: { apiCode: code } };
+  if (lower.includes("token") || lower.includes("auth") || lower.includes("unauthor")) {
+    return new AuthError(message, {
+      ...opts,
+      hint: "\u786E\u8BA4 Token \u672A\u8FC7\u671F\u4E14\u8D26\u53F7\u5DF2\u5B8C\u6210\u5B9E\u540D\u8BA4\u8BC1\u3002"
+    });
+  }
+  if (text.includes("\u5B9E\u540D")) {
+    return new AuthError(message, {
+      ...opts,
+      hint: "\u5B98\u65B9\u5F00\u653E API \u8981\u6C42\u5B8C\u6210\u4E2A\u4EBA\u6216\u4F01\u4E1A\u5B9E\u540D\u8BA4\u8BC1\u540E\u624D\u80FD\u8C03\u7528\u3002"
+    });
+  }
+  if (text.includes("\u4F59\u989D") || lower.includes("balance") || lower.includes("insufficient fund")) {
+    return new BudgetError(message, { ...opts, hint: "\u8BF7\u5148\u5145\u503C\uFF0C\u6216\u964D\u4F4E\u6240\u9700 GPU \u89C4\u683C\u3002" });
+  }
+  if (text.includes("\u5E93\u5B58") || text.includes("\u65E0\u53EF\u7528") || text.includes("\u8D44\u6E90\u4E0D\u8DB3") || text.includes("\u552E\u7F44") || lower.includes("no stock") || lower.includes("sold out") || lower.includes("no available")) {
+    return new NoStockError(message, {
+      ...opts,
+      hint: "\u5B98\u65B9 API \u6CA1\u6709\u5E93\u5B58\u67E5\u8BE2\u63A5\u53E3\uFF0C\u53EA\u80FD\u6362 GPU \u89C4\u683C\u6216\u5730\u533A\u91CD\u8BD5\u3002"
+    });
+  }
+  if (text.includes("\u4E0D\u5B58\u5728") || lower.includes("not found") || lower.includes("no such")) {
+    return new NotFoundError(message, opts);
+  }
+  return new AutoDLError(message, { ...opts, code: "API_ERROR" });
+}
+
+// src/core/duration.ts
+var PATTERN = /^(\d+(?:\.\d+)?)(s|m|h|d)?$/i;
+var UNIT_SECONDS = {
+  s: 1,
+  m: 60,
+  h: 3600,
+  d: 86400
+};
+function parseDuration(input, { bareUnit = "m" } = {}) {
+  const match = PATTERN.exec(input.trim());
+  if (!match) {
+    throw new UsageError(`\u65E0\u6CD5\u89E3\u6790\u65F6\u957F "${input}"`, {
+      hint: "\u652F\u6301\u7684\u683C\u5F0F\uFF1A30s\u300145m\u30012h\u30011d\uFF0C\u6216\u7EAF\u6570\u5B57\uFF08\u9ED8\u8BA4\u6309\u5206\u949F\uFF09"
+    });
+  }
+  const value = Number(match[1]);
+  const unit = (match[2] ?? bareUnit).toLowerCase();
+  const factor = UNIT_SECONDS[unit];
+  if (factor === void 0) {
+    throw new UsageError(`\u4E0D\u652F\u6301\u7684\u65F6\u957F\u5355\u4F4D "${unit}"`, { hint: "\u652F\u6301 s / m / h / d" });
+  }
+  const seconds = Math.round(value * factor);
+  if (seconds <= 0) {
+    throw new UsageError(`\u65F6\u957F\u5FC5\u987B\u5927\u4E8E 0\uFF0C\u6536\u5230 "${input}"`);
+  }
+  return seconds;
+}
+function formatDuration(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  const d = Math.floor(seconds / 86400);
+  const h = Math.floor(seconds % 86400 / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  const parts = [];
+  if (d) parts.push(`${d}d`);
+  if (h) parts.push(`${h}h`);
+  if (m) parts.push(`${m}m`);
+  return parts.join("") || `${seconds}s`;
+}
+
+// src/core/money.ts
+var MILLI_PER_YUAN = 1e3;
+function milliToYuan(milli) {
+  if (milli === null || milli === void 0 || Number.isNaN(milli)) return 0;
+  return Math.round(milli / MILLI_PER_YUAN * 100) / 100;
+}
+function yuanToMilli(yuan) {
+  return Math.round(yuan * MILLI_PER_YUAN);
+}
+function formatYuan(yuan) {
+  return `\xA5${yuan.toFixed(2)}`;
+}
+function formatRate(yuanPerHour, unit = "\u65F6") {
+  return `${formatYuan(yuanPerHour)}/${unit}`;
+}
+function estimateCost(yuanPerHour, seconds) {
+  const raw = yuanPerHour * seconds / 3600;
+  if (raw <= 0) return 0;
+  return Math.max(0.01, Math.round(raw * 100) / 100);
+}
+
+// src/core/schemas.ts
+import { z } from "zod";
+var nullTime = z.object({ Time: z.string(), Valid: z.boolean() }).transform((v) => v.Valid ? v.Time : null);
+var maybeTime = z.union([nullTime, z.string(), z.null()]).transform((v) => v ?? null);
+var instanceStatusSchema = z.enum([
+  "creating",
+  "starting",
+  "running",
+  "shutting_down",
+  "shutdown",
+  "releasing",
+  "released",
+  "failed"
+]);
+var looseStatusSchema = z.string();
+var rawInstanceSchema = z.object({
+  uuid: z.string(),
+  name: z.string().nullish(),
+  status: z.string(),
+  sub_status: z.string().nullish(),
+  machine_id: z.string().nullish(),
+  machine_alias: z.string().nullish(),
+  region_sign: z.string().nullish(),
+  region_name: z.string().nullish(),
+  charge_type: z.string().nullish(),
+  start_mode: z.string().nullish(),
+  req_gpu_amount: z.number().nullish(),
+  gpu_spec_uuid: z.string().nullish(),
+  created_at: maybeTime.nullish(),
+  status_at: maybeTime.nullish(),
+  started_at: maybeTime.nullish(),
+  stopped_at: maybeTime.nullish(),
+  expired_at: maybeTime.nullish(),
+  timed_shutdown_at: maybeTime.nullish()
+}).passthrough();
+function normalizeInstance(raw) {
+  const v = rawInstanceSchema.parse(raw);
+  return {
+    uuid: v.uuid,
+    name: v.name ?? null,
+    status: v.status,
+    subStatus: v.sub_status || null,
+    machineId: v.machine_id || null,
+    regionSign: v.region_sign || null,
+    regionName: v.region_name || null,
+    chargeType: v.charge_type || null,
+    startMode: v.start_mode || null,
+    gpuSpec: v.gpu_spec_uuid || null,
+    gpuNum: v.req_gpu_amount ?? 0,
+    createdAt: v.created_at ?? null,
+    startedAt: v.started_at ?? null,
+    stoppedAt: v.stopped_at ?? null,
+    expiredAt: v.expired_at ?? null,
+    timedShutdownAt: v.timed_shutdown_at ?? null
+  };
+}
+var usageInfoSchema = z.object({
+  container_id: z.string().nullish(),
+  cpu_usage_percent: z.number().nullish(),
+  mem_usage_percent: z.number().nullish(),
+  mem_usage: z.number().nullish(),
+  mem_limit: z.number().nullish(),
+  root_fs_used_size: z.number().nullish(),
+  root_fs_total_size: z.number().nullish(),
+  data_disk_used_size: z.number().nullish(),
+  data_disk_total_size: z.number().nullish()
+}).passthrough();
+var rawSnapshotSchema = z.object({
+  region_sign: z.string().nullish(),
+  payg_price: z.number().nullish(),
+  origin_pay_price: z.number().nullish(),
+  snapshot_gpu_alias_name: z.string().nullish(),
+  chip_corp: z.string().nullish(),
+  cpu_arch: z.string().nullish(),
+  ssh_command: z.string().nullish(),
+  proxy_host: z.string().nullish(),
+  root_password: z.string().nullish(),
+  ssh_port: z.number().nullish(),
+  jupyter_token: z.string().nullish(),
+  jupyter_domain: z.string().nullish(),
+  expand_system_disk_size: z.number().nullish(),
+  system_init_disk_size: z.number().nullish(),
+  usage_info: usageInfoSchema.nullish()
+}).passthrough();
+var SERVICE_DOMAIN = /^service_(\d+)_domain$/;
+function normalizeSnapshot(raw) {
+  const v = rawSnapshotSchema.parse(raw);
+  const bag = raw;
+  const services = [];
+  for (const [key, value] of Object.entries(bag)) {
+    const match = SERVICE_DOMAIN.exec(key);
+    if (!match || typeof value !== "string" || !value) continue;
+    const port = Number(match[1]);
+    const protocol = bag[`service_${port}_port_protocol`];
+    services.push({
+      port,
+      domain: value,
+      protocol: typeof protocol === "string" && protocol ? protocol : null
+    });
+  }
+  services.sort((a, b) => a.port - b.port);
+  const usage = v.usage_info ?? {};
+  return {
+    regionSign: v.region_sign || null,
+    gpuAlias: v.snapshot_gpu_alias_name || null,
+    chipCorp: v.chip_corp || null,
+    cpuArch: v.cpu_arch || null,
+    priceYuanPerHour: milliToYuan(v.payg_price),
+    originalPriceYuanPerHour: milliToYuan(v.origin_pay_price),
+    ssh: {
+      command: v.ssh_command || null,
+      host: v.proxy_host || null,
+      port: v.ssh_port ?? null,
+      user: "root",
+      password: v.root_password || null
+    },
+    jupyter: { token: v.jupyter_token || null, domain: v.jupyter_domain || null },
+    services,
+    disk: {
+      systemInitBytes: v.system_init_disk_size ?? 0,
+      systemExpandBytes: v.expand_system_disk_size ?? 0
+    },
+    usage: {
+      cpuPercent: usage.cpu_usage_percent ?? null,
+      memPercent: usage.mem_usage_percent ?? null,
+      memUsedBytes: usage.mem_usage ?? null,
+      memLimitBytes: usage.mem_limit ?? null,
+      rootFsUsedBytes: usage.root_fs_used_size ?? null,
+      rootFsTotalBytes: usage.root_fs_total_size ?? null,
+      dataDiskUsedBytes: usage.data_disk_used_size ?? null,
+      dataDiskTotalBytes: usage.data_disk_total_size ?? null
+    }
+  };
+}
+var rawBalanceSchema = z.object({
+  assets: z.number().nullish(),
+  accumulate: z.number().nullish(),
+  voucher_balance: z.number().nullish()
+}).passthrough();
+function normalizeBalance(raw) {
+  const v = rawBalanceSchema.parse(raw);
+  return {
+    balanceYuan: milliToYuan(v.assets),
+    accumulatedYuan: milliToYuan(v.accumulate),
+    voucherYuan: milliToYuan(v.voucher_balance)
+  };
+}
+var rawImageSchema = z.object({
+  image_uuid: z.string(),
+  name: z.string().nullish(),
+  image_name: z.string().nullish(),
+  status: z.string().nullish(),
+  image_size: z.number().nullish(),
+  create_at: z.string().nullish(),
+  created_at: z.string().nullish()
+}).passthrough();
+function normalizeImage(raw) {
+  const v = rawImageSchema.parse(raw);
+  return {
+    imageUuid: v.image_uuid,
+    name: v.name ?? v.image_name ?? "",
+    status: v.status ?? null,
+    sizeBytes: v.image_size ?? 0,
+    createdAt: v.create_at ?? v.created_at ?? null
+  };
+}
+var paginationSchema = z.object({
+  page_index: z.number().nullish(),
+  page_size: z.number().nullish(),
+  max_page: z.number().nullish(),
+  result_total: z.number().nullish()
+}).passthrough();
+function normalizePagination(raw) {
+  const v = paginationSchema.parse(raw ?? {});
+  return {
+    pageIndex: v.page_index ?? 1,
+    pageSize: v.page_size ?? 0,
+    maxPage: v.max_page ?? 1,
+    total: v.result_total ?? 0
+  };
+}
+function redactSnapshot(snapshot) {
+  return {
+    ...snapshot,
+    ssh: { ...snapshot.ssh, password: snapshot.ssh.password ? "***" : null },
+    jupyter: { ...snapshot.jupyter, token: snapshot.jupyter.token ? "***" : null }
+  };
+}
+
+// src/core/endpoints/instance.ts
+var MAX_GPU_NUM = 4;
+var MAX_DISK_GB = 500;
+function validateCreateInput(input) {
+  if (!Number.isInteger(input.gpuNum) || input.gpuNum < 1 || input.gpuNum > MAX_GPU_NUM) {
+    throw new UsageError(`GPU \u6570\u91CF\u5FC5\u987B\u662F 1-${MAX_GPU_NUM} \u4E4B\u95F4\u7684\u6574\u6570\uFF0C\u6536\u5230 ${input.gpuNum}`);
+  }
+  const disk = input.expandSystemDiskGb ?? 0;
+  if (!Number.isInteger(disk) || disk < 0 || disk > MAX_DISK_GB) {
+    throw new UsageError(`\u7CFB\u7EDF\u76D8\u6269\u5BB9\u5FC5\u987B\u662F 0-${MAX_DISK_GB} GB \u4E4B\u95F4\u7684\u6574\u6570\uFF0C\u6536\u5230 ${disk}`);
+  }
+  if (!input.imageUuid) {
+    throw new UsageError("\u5FC5\u987B\u6307\u5B9A\u955C\u50CF\uFF08--image\uFF09");
+  }
+}
+async function createInstance(client, input) {
+  validateCreateInput(input);
+  const payload = {
+    req_gpu_amount: input.gpuNum,
+    gpu_spec_uuid: input.gpuSpec,
+    image_uuid: input.imageUuid,
+    cuda_v_from: input.cudaFrom,
+    expand_system_disk_by_gb: input.expandSystemDiskGb ?? 0
+  };
+  if (input.regions?.length) payload.data_center_list = input.regions;
+  if (input.name) payload.instance_name = input.name;
+  if (input.startCommand) payload.start_command = input.startCommand;
+  const uuid = await client.post("/api/v1/dev/instance/pro/create", payload, {
+    maxRetries: 0
+  });
+  return uuid;
+}
+async function listInstancesPage(client, options2 = {}) {
+  const data = await client.post(
+    "/api/v1/dev/instance/pro/list",
+    { page_index: options2.pageIndex ?? 1, page_size: options2.pageSize ?? 50 }
+  );
+  const list = Array.isArray(data?.list) ? data.list : [];
+  return {
+    instances: list.map(normalizeInstance),
+    pagination: normalizePagination(data)
+  };
+}
+async function listAllInstances(client) {
+  const pageSize = 100;
+  const first = await listInstancesPage(client, { pageIndex: 1, pageSize });
+  const all = [...first.instances];
+  for (let page = 2; page <= first.pagination.maxPage; page++) {
+    const next = await listInstancesPage(client, { pageIndex: page, pageSize });
+    all.push(...next.instances);
+    if (next.instances.length === 0) break;
+  }
+  return all;
+}
+async function getInstanceStatus(client, uuid) {
+  return client.get("/api/v1/dev/instance/pro/status", { instance_uuid: uuid });
+}
+async function getInstanceSnapshot(client, uuid) {
+  const data = await client.get("/api/v1/dev/instance/pro/snapshot", {
+    instance_uuid: uuid
+  });
+  return normalizeSnapshot(data);
+}
+async function findInstance(client, uuid) {
+  const all = await listAllInstances(client);
+  const found = all.find((instance) => instance.uuid === uuid);
+  if (!found) {
+    throw new NotFoundError(`\u672A\u627E\u5230\u5B9E\u4F8B ${uuid}`, {
+      hint: "\u8FD0\u884C `autodl ls` \u67E5\u770B\u5F53\u524D\u8D26\u53F7\u4E0B\u7684\u5B9E\u4F8B\u3002"
+    });
+  }
+  return found;
+}
+async function powerOnInstance(client, uuid, options2 = {}) {
+  const payload = { instance_uuid: uuid, payload: "gpu" };
+  if (options2.startCommand) payload.start_command = options2.startCommand;
+  await client.post("/api/v1/dev/instance/pro/power_on", payload, { maxRetries: 0 });
+}
+async function powerOffInstance(client, uuid) {
+  await client.post("/api/v1/dev/instance/pro/power_off", { instance_uuid: uuid });
+}
+async function releaseInstance(client, uuid) {
+  await client.post("/api/v1/dev/instance/pro/release", { instance_uuid: uuid }, { maxRetries: 0 });
+}
+
+// src/output/format.ts
+import Table from "cli-table3";
+import pc from "picocolors";
+var options = { json: false, color: true, verbose: false, quiet: false };
+function configureOutput(next) {
+  options = { ...options, ...next };
+  if (!options.color) {
+    process.env.NO_COLOR = "1";
+  }
+}
+var isJson = () => options.json;
+var isVerbose = () => options.verbose;
+function note(message) {
+  if (options.json || options.quiet) return;
+  process.stderr.write(`${message}
+`);
+}
+function success(message) {
+  if (options.json || options.quiet) return;
+  process.stderr.write(`${pc.green("\u2714")} ${message}
+`);
+}
+function warn(message) {
+  if (options.json || options.quiet) return;
+  process.stderr.write(`${pc.yellow("!")} ${message}
+`);
+}
+function debug(message) {
+  if (!options.verbose || options.quiet) return;
+  process.stderr.write(`${pc.dim(`[debug] ${message}`)}
+`);
+}
+function emit(data, renderHuman) {
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data }, null, 2)}
+`);
+    return;
+  }
+  renderHuman();
+}
+function emitError(error) {
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify({ ok: false, error: error.toJSON() }, null, 2)}
+`);
+    return;
+  }
+  process.stderr.write(`${pc.red("\u2716")} ${error.message}
+`);
+  if (error.hint) process.stderr.write(`  ${pc.dim(error.hint)}
+`);
+  if (error.requestId) process.stderr.write(`  ${pc.dim(`request_id: ${error.requestId}`)}
+`);
+  if (options.verbose && error.cause instanceof Error && error.cause.stack) {
+    process.stderr.write(`${pc.dim(error.cause.stack)}
+`);
+  }
+}
+function table(head, rows) {
+  const t2 = new Table({
+    head: head.map((h) => pc.bold(h)),
+    style: { head: [], border: [] },
+    chars: {
+      top: "\u2500",
+      "top-mid": "\u252C",
+      "top-left": "\u250C",
+      "top-right": "\u2510",
+      bottom: "\u2500",
+      "bottom-mid": "\u2534",
+      "bottom-left": "\u2514",
+      "bottom-right": "\u2518",
+      left: "\u2502",
+      "left-mid": "\u251C",
+      mid: "\u2500",
+      "mid-mid": "\u253C",
+      right: "\u2502",
+      "right-mid": "\u2524",
+      middle: "\u2502"
+    }
+  });
+  for (const row of rows) t2.push(row.map((cell) => String(cell)));
+  return t2.toString();
+}
+function printTable(head, rows) {
+  process.stdout.write(`${table(head, rows)}
+`);
+}
+function printKeyValues(pairs) {
+  const width = Math.max(...pairs.map(([key]) => stringWidth(key)));
+  for (const [key, value] of pairs) {
+    const pad = " ".repeat(Math.max(0, width - stringWidth(key)));
+    process.stdout.write(`${pc.dim(key)}${pad}  ${value}
+`);
+  }
+}
+function stringWidth(input) {
+  let width = 0;
+  for (const char of input) {
+    const code = char.codePointAt(0) ?? 0;
+    width += code >= 4352 && code <= 4447 || code >= 11904 && code <= 42191 || code >= 44032 && code <= 55203 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65135 || code >= 65280 && code <= 65376 || code >= 65504 && code <= 65510 ? 2 : 1;
+  }
+  return width;
+}
+function colorStatus(status) {
+  switch (status) {
+    case "running":
+      return pc.green(status);
+    case "starting":
+    case "creating":
+      return pc.cyan(status);
+    case "shutting_down":
+    case "shutdown":
+      return pc.dim(status);
+    case "failed":
+    case "released":
+      return pc.red(status);
+    default:
+      return status;
+  }
+}
+function formatBytes(bytes) {
+  if (!bytes) return "-";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let value = bytes;
+  let index = 0;
+  while (value >= 1024 && index < units.length - 1) {
+    value /= 1024;
+    index++;
+  }
+  return `${value.toFixed(value >= 100 || index === 0 ? 0 : 1)}${units[index]}`;
+}
+function formatTime(iso) {
+  if (!iso) return "-";
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) return "-";
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+
+// src/core/waiters.ts
+var TERMINAL_FAILURES = /* @__PURE__ */ new Set(["failed", "released", "releasing"]);
+function sleep2(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(new AutoDLError("\u64CD\u4F5C\u5DF2\u53D6\u6D88"));
+      },
+      { once: true }
+    );
+  });
+}
+async function waitForStatus(client, uuid, targets, options2 = {}) {
+  const timeoutMs = options2.timeoutMs ?? 10 * 60 * 1e3;
+  const intervalMs = options2.intervalMs ?? 5e3;
+  const wanted = new Set(targets);
+  const startedAt = Date.now();
+  for (; ; ) {
+    const status = await getInstanceStatus(client, uuid);
+    const elapsed = Date.now() - startedAt;
+    options2.onPoll?.(status, elapsed);
+    if (wanted.has(status)) return status;
+    if (TERMINAL_FAILURES.has(status) && !wanted.has(status)) {
+      throw new AutoDLError(
+        `\u5B9E\u4F8B ${uuid} \u8FDB\u5165\u4E86 "${status}" \u72B6\u6001\uFF0C\u65E0\u6CD5\u7EE7\u7EED\u7B49\u5F85 ${targets.join("/")}`,
+        {
+          details: { status }
+        }
+      );
+    }
+    if (elapsed >= timeoutMs) {
+      throw new TimeoutError(
+        `\u7B49\u5F85\u5B9E\u4F8B ${uuid} \u53D8\u4E3A ${targets.join("/")} \u8D85\u65F6\uFF08\u5F53\u524D\u72B6\u6001 "${status}"\uFF09`,
+        { hint: "\u53EF\u4EE5\u7A0D\u540E\u8FD0\u884C `autodl info <id>` \u67E5\u770B\u5B9E\u4F8B\u662F\u5426\u5DF2\u5C31\u7EEA\u3002", details: { status } }
+      );
+    }
+    await sleep2(intervalMs, options2.signal);
+  }
+}
+var waitForRunning = (client, uuid, options2) => waitForStatus(client, uuid, ["running"], options2);
+var waitForShutdown = (client, uuid, options2) => waitForStatus(client, uuid, ["shutdown"], options2);
+
+// src/ssh/credentials.ts
+import { Client } from "ssh2";
+
+// src/output/i18n.ts
+var MESSAGES = {
+  zh: {
+    "account.balance": "\u4F59\u989D",
+    "account.accumulated": "\u7D2F\u8BA1\u6D88\u8D39",
+    "account.voucher": "\u4EE3\u91D1\u5238",
+    "login.prompt": "\u8BF7\u7C98\u8D34 AutoDL \u5F00\u53D1\u8005 Token",
+    "login.hint": "\u63A7\u5236\u53F0 \u2192 \u8BBE\u7F6E \u2192 \u5F00\u53D1\u8005 Token\uFF08\u9700\u5DF2\u5B8C\u6210\u5B9E\u540D\u8BA4\u8BC1\uFF09",
+    "login.verifying": "\u6B63\u5728\u9A8C\u8BC1 Token\u2026",
+    "login.success": "Token \u5DF2\u9A8C\u8BC1\u5E76\u4FDD\u5B58\u5230",
+    "login.cancelled": "\u5DF2\u53D6\u6D88",
+    "logout.done": "\u5DF2\u6E05\u9664\u672C\u5730 Token",
+    "instance.none": "\u5F53\u524D\u8D26\u53F7\u4E0B\u6CA1\u6709\u5B9E\u4F8B",
+    "instance.creating": "\u6B63\u5728\u521B\u5EFA\u5B9E\u4F8B\u2026",
+    "instance.created": "\u5B9E\u4F8B\u5DF2\u521B\u5EFA",
+    "instance.waiting": "\u7B49\u5F85\u5B9E\u4F8B\u5C31\u7EEA\u2026",
+    "instance.ready": "\u5B9E\u4F8B\u5DF2\u5C31\u7EEA",
+    "instance.poweringOn": "\u6B63\u5728\u5F00\u673A\u2026",
+    "instance.poweringOff": "\u6B63\u5728\u5173\u673A\u2026",
+    "instance.released": "\u5B9E\u4F8B\u5DF2\u91CA\u653E",
+    "instance.confirmRelease": "\u91CA\u653E\u540E\u5B9E\u4F8B\u6570\u636E\u5C06\u88AB\u6C38\u4E45\u6E05\u7A7A\uFF0C\u786E\u8BA4\u91CA\u653E",
+    "guard.armed": "\u5DF2\u8BBE\u7F6E\u5230\u671F\u81EA\u52A8\u5173\u673A",
+    "guard.armFailed": "\u5B9E\u4F8B\u5185\u5B9A\u65F6\u5173\u673A\u672A\u80FD\u8BBE\u7F6E\uFF0C\u5DF2\u6539\u4E3A\u4EC5\u4F9D\u8D56\u672C\u5730\u53F0\u8D26",
+    "guard.sweptOne": "\u5DF2\u81EA\u52A8\u5173\u95ED\u8D85\u65F6\u5B9E\u4F8B",
+    "guard.blocked": "\u4F59\u989D\u4F4E\u4E8E\u9608\u503C\uFF0C\u5DF2\u963B\u6B62\u521B\u5EFA\u5B9E\u4F8B",
+    "ssh.connecting": "\u6B63\u5728\u8FDE\u63A5\u2026",
+    "ssh.refreshing": "SSH \u51ED\u8BC1\u53EF\u80FD\u5DF2\u53D8\u5316\uFF0C\u6B63\u5728\u91CD\u65B0\u83B7\u53D6\u2026",
+    "run.syncing": "\u6B63\u5728\u540C\u6B65\u6587\u4EF6\u2026",
+    "run.executing": "\u6B63\u5728\u8FDC\u7A0B\u6267\u884C\u2026",
+    "run.pulling": "\u6B63\u5728\u56DE\u4F20\u4EA7\u7269\u2026",
+    "run.finished": "\u6267\u884C\u5B8C\u6210",
+    "run.cleanup": "\u6B63\u5728\u6536\u5C3E\u2026",
+    "common.cancelled": "\u5DF2\u53D6\u6D88",
+    "common.yes": "\u662F",
+    "common.no": "\u5426"
+  },
+  en: {
+    "account.balance": "Balance",
+    "account.accumulated": "Total spend",
+    "account.voucher": "Vouchers",
+    "login.prompt": "Paste your AutoDL developer token",
+    "login.hint": "Console \u2192 Settings \u2192 Developer Token (requires identity verification)",
+    "login.verifying": "Verifying token\u2026",
+    "login.success": "Token verified and saved to",
+    "login.cancelled": "Cancelled",
+    "logout.done": "Local token cleared",
+    "instance.none": "No instances on this account",
+    "instance.creating": "Creating instance\u2026",
+    "instance.created": "Instance created",
+    "instance.waiting": "Waiting for the instance to be ready\u2026",
+    "instance.ready": "Instance ready",
+    "instance.poweringOn": "Powering on\u2026",
+    "instance.poweringOff": "Powering off\u2026",
+    "instance.released": "Instance released",
+    "instance.confirmRelease": "Releasing wipes all data permanently. Release",
+    "guard.armed": "Auto-shutdown timer armed",
+    "guard.armFailed": "Could not arm the in-instance timer; falling back to the local ledger",
+    "guard.sweptOne": "Auto-stopped an instance past its TTL",
+    "guard.blocked": "Balance below threshold; instance creation blocked",
+    "ssh.connecting": "Connecting\u2026",
+    "ssh.refreshing": "SSH credentials may have rotated, refreshing\u2026",
+    "run.syncing": "Syncing files\u2026",
+    "run.executing": "Running remotely\u2026",
+    "run.pulling": "Downloading artefacts\u2026",
+    "run.finished": "Done",
+    "run.cleanup": "Cleaning up\u2026",
+    "common.cancelled": "Cancelled",
+    "common.yes": "yes",
+    "common.no": "no"
+  }
+};
+var current = "zh";
+function resolveLang(explicit) {
+  const candidate = (explicit ?? process.env.AUTODL_LANG ?? "").toLowerCase();
+  if (candidate.startsWith("en")) return "en";
+  if (candidate.startsWith("zh")) return "zh";
+  return "zh";
+}
+function setLang(lang) {
+  current = lang;
+}
+function t(key) {
+  return MESSAGES[current][key] ?? MESSAGES.zh[key] ?? key;
+}
+
+// src/ssh/credentials.ts
+async function getCredentials(client, uuid, options2 = {}) {
+  let status = await getInstanceStatus(client, uuid);
+  if (status !== "running") {
+    if (!options2.autoStart) {
+      throw new SSHError(`\u5B9E\u4F8B ${uuid} \u5F53\u524D\u72B6\u6001\u4E3A "${status}"\uFF0C\u65E0\u6CD5\u5EFA\u7ACB SSH \u8FDE\u63A5`, {
+        hint: "\u5148\u8FD0\u884C `autodl start <id>`\uFF0C\u6216\u52A0 --start \u8BA9\u547D\u4EE4\u81EA\u52A8\u5F00\u673A\u3002",
+        details: { status }
+      });
+    }
+    if (status === "shutting_down") {
+      note("\u5B9E\u4F8B\u6B63\u5728\u5173\u673A\u4E2D\uFF0C\u7B49\u5F85\u5173\u673A\u5B8C\u6210\u540E\u518D\u5F00\u673A\u2026");
+      status = await waitForShutdown(client, uuid, {
+        ...options2.waitTimeoutMs !== void 0 ? { timeoutMs: options2.waitTimeoutMs } : {},
+        ...options2.pollIntervalMs !== void 0 ? { intervalMs: options2.pollIntervalMs } : {},
+        ...options2.signal ? { signal: options2.signal } : {}
+      });
+    }
+    if (status === "shutdown") {
+      note(t("instance.poweringOn"));
+      await powerOnInstance(client, uuid);
+    }
+    status = await waitForRunning(client, uuid, {
+      ...options2.waitTimeoutMs !== void 0 ? { timeoutMs: options2.waitTimeoutMs } : {},
+      ...options2.pollIntervalMs !== void 0 ? { intervalMs: options2.pollIntervalMs } : {},
+      ...options2.signal ? { signal: options2.signal } : {},
+      onPoll: (s) => debug(`\u5B9E\u4F8B ${uuid} \u72B6\u6001\uFF1A${s}`)
+    });
+  }
+  const snapshot = await getInstanceSnapshot(client, uuid);
+  const { host, port, password } = snapshot.ssh;
+  if (!host || !port || !password) {
+    throw new SSHError(`\u5B9E\u4F8B ${uuid} \u5C1A\u672A\u8FD4\u56DE\u5B8C\u6574\u7684 SSH \u4FE1\u606F`, {
+      hint: "\u5B9E\u4F8B\u53EF\u80FD\u4ECD\u5728\u542F\u52A8\u4E2D\uFF0C\u7A0D\u7B49\u7247\u523B\u540E\u91CD\u8BD5\u3002",
+      details: { host, port, hasPassword: Boolean(password) }
+    });
+  }
+  return { uuid, host, port, user: "root", password };
+}
+var RETRY_DELAYS_MS = [2e3, 5e3, 8e3];
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function connectOnce(creds, options2) {
+  return new Promise((resolve, reject) => {
+    const conn = new Client();
+    const settle = (err) => {
+      conn.removeAllListeners("ready");
+      conn.removeAllListeners("error");
+      if (err) reject(err);
+      else resolve(conn);
+    };
+    conn.once("ready", () => settle());
+    conn.once("error", (err) => {
+      conn.end();
+      settle(err);
+    });
+    conn.connect({
+      host: creds.host,
+      port: creds.port,
+      username: creds.user,
+      password: creds.password,
+      readyTimeout: options2.connectTimeoutMs ?? 3e4,
+      keepaliveInterval: options2.keepaliveIntervalMs ?? 15e3,
+      // AutoDL's proxy hosts reuse addresses across instances, so a known_hosts
+      // check would fail constantly and teach users to ignore warnings.
+      algorithms: void 0
+    });
+  });
+}
+async function withSSH(client, uuid, fn, options2 = {}) {
+  let lastError;
+  const attempts = Math.max(1, options2.connectAttempts ?? 3);
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    if (attempt > 0) {
+      note(t("ssh.refreshing"));
+      await delay(RETRY_DELAYS_MS[attempt - 1] ?? RETRY_DELAYS_MS.at(-1) ?? 5e3);
+    }
+    const creds = await getCredentials(client, uuid, options2);
+    let conn;
+    try {
+      conn = await connectOnce(creds, options2);
+    } catch (err) {
+      lastError = err;
+      debug(`SSH \u8FDE\u63A5 ${creds.host}:${creds.port} \u5931\u8D25\uFF1A${err.message}`);
+      continue;
+    }
+    try {
+      return await fn(conn, creds);
+    } finally {
+      conn.end();
+    }
+  }
+  throw new SSHError(`\u65E0\u6CD5\u8FDE\u63A5\u5230\u5B9E\u4F8B ${uuid}\uFF08\u5DF2\u5C1D\u8BD5 ${attempts} \u6B21\uFF09`, {
+    hint: "\u5B9E\u4F8B\u53EF\u80FD\u4ECD\u5728\u542F\u52A8\u4E2D\uFF0C\u7A0D\u540E\u91CD\u8BD5\uFF1B\u6216\u8FD0\u884C `autodl info <id>` \u624B\u52A8\u6838\u5BF9 SSH \u7AEF\u53E3\u3002",
+    cause: lastError
+  });
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+// src/ssh/exec.ts
+function buildCommand(command, options2) {
+  const parts = [];
+  for (const [key, value] of Object.entries(options2.env ?? {})) {
+    parts.push(`export ${key}=${JSON.stringify(value)}`);
+  }
+  if (options2.cwd) parts.push(`cd ${JSON.stringify(options2.cwd)}`);
+  parts.push(command);
+  const inner = parts.join(" && ");
+  return options2.loginShell === false ? inner : `bash -lc ${shellQuote(inner)}`;
+}
+function execOnConnection(conn, command, options2 = {}) {
+  const capture = options2.capture ?? true;
+  const full = buildCommand(command, options2);
+  return new Promise((resolve, reject) => {
+    conn.exec(full, { pty: options2.pty ?? false }, (err, stream) => {
+      if (err) {
+        reject(new SSHError(`\u8FDC\u7A0B\u547D\u4EE4\u542F\u52A8\u5931\u8D25\uFF1A${err.message}`, { cause: err }));
+        return;
+      }
+      let stdout = "";
+      let stderr = "";
+      let settled = false;
+      const timer = options2.timeoutMs ? setTimeout(() => {
+        settled = true;
+        stream.close();
+        reject(
+          new TimeoutError(`\u8FDC\u7A0B\u547D\u4EE4\u8D85\u8FC7 ${options2.timeoutMs}ms \u672A\u7ED3\u675F\uFF0C\u5DF2\u7EC8\u6B62`, {
+            details: { command }
+          })
+        );
+      }, options2.timeoutMs) : void 0;
+      stream.on("data", (chunk) => {
+        if (capture) stdout += chunk.toString("utf8");
+        options2.stdout?.write(chunk);
+      });
+      stream.stderr.on("data", (chunk) => {
+        if (capture) stderr += chunk.toString("utf8");
+        options2.stderr?.write(chunk);
+      });
+      stream.on("close", (code, signal) => {
+        if (timer) clearTimeout(timer);
+        if (settled) return;
+        resolve({ exitCode: code ?? null, signal: signal ?? null, stdout, stderr });
+      });
+      stream.on("error", (streamErr) => {
+        if (timer) clearTimeout(timer);
+        if (settled) return;
+        reject(new SSHError(`\u8FDC\u7A0B\u547D\u4EE4\u6267\u884C\u51FA\u9519\uFF1A${streamErr.message}`, { cause: streamErr }));
+      });
+    });
+  });
+}
+async function execCommand(client, uuid, command, options2 = {}) {
+  return withSSH(client, uuid, (conn) => execOnConnection(conn, command, options2), options2);
+}
+
+// src/config/state.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+var EMPTY = { version: 1, tracked: {} };
+var statePath = () => join2(configDir(), "state.json");
+function readState() {
+  const file = statePath();
+  if (!existsSync2(file)) return { ...EMPTY, tracked: {} };
+  try {
+    const parsed = JSON.parse(readFileSync2(file, "utf8"));
+    return { version: 1, tracked: parsed.tracked ?? {} };
+  } catch {
+    return { ...EMPTY, tracked: {} };
+  }
+}
+function writeState(state) {
+  const file = statePath();
+  mkdirSync2(dirname2(file), { recursive: true, mode: 448 });
+  writeFileSync2(file, `${JSON.stringify(state, null, 2)}
+`, { mode: 384 });
+}
+function trackInstance(entry) {
+  const state = readState();
+  state.tracked[entry.uuid] = entry;
+  writeState(state);
+}
+function untrackInstance(uuid) {
+  const state = readState();
+  if (state.tracked[uuid]) {
+    delete state.tracked[uuid];
+    writeState(state);
+  }
+}
+function listTracked() {
+  return Object.values(readState().tracked);
+}
+function listExpired(now = Date.now()) {
+  return listTracked().filter((entry) => entry.expiresAt <= now);
+}
+
+// src/guard/ttl.ts
+var PID_FILE = "/tmp/.autodl-cli-ttl.pid";
+function buildTTLSnippet(seconds) {
+  return `(sleep ${seconds} && /usr/bin/shutdown -h now) >/dev/null 2>&1 &`;
+}
+function composeStartCommand(ttlSeconds, userCommand) {
+  const parts = [];
+  if (ttlSeconds && ttlSeconds > 0) parts.push(buildTTLSnippet(ttlSeconds));
+  if (userCommand?.trim()) parts.push(userCommand.trim());
+  return parts.length ? parts.join(" ") : void 0;
+}
+async function armTTLOverSSH(client, uuid, seconds) {
+  const command = [
+    `if [ -f ${PID_FILE} ]; then kill "$(cat ${PID_FILE})" 2>/dev/null || true; fi`,
+    `(sleep ${seconds} && /usr/bin/shutdown -h now) >/dev/null 2>&1 &`,
+    `echo $! > ${PID_FILE}`
+  ].join("; ");
+  try {
+    const result = await execCommand(client, uuid, command, { capture: true, timeoutMs: 3e4 });
+    if (result.exitCode !== 0) {
+      debug(`\u5B9A\u65F6\u5173\u673A\u547D\u4EE4\u9000\u51FA\u7801 ${result.exitCode}\uFF1A${result.stderr.trim()}`);
+      return false;
+    }
+    return true;
+  } catch (err) {
+    debug(`\u5B9A\u65F6\u5173\u673A\u547D\u4EE4\u6267\u884C\u5931\u8D25\uFF1A${err.message}`);
+    return false;
+  }
+}
+async function disarmTTLOverSSH(client, uuid) {
+  const command = `if [ -f ${PID_FILE} ]; then kill "$(cat ${PID_FILE})" 2>/dev/null; rm -f ${PID_FILE}; fi; /usr/bin/shutdown -c 2>/dev/null || true`;
+  try {
+    await execCommand(client, uuid, command, { capture: false, timeoutMs: 3e4 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function recordTTL(input) {
+  const now = Date.now();
+  trackInstance({
+    uuid: input.uuid,
+    ...input.name ? { name: input.name } : {},
+    ttlSeconds: input.ttlSeconds,
+    expiresAt: now + input.ttlSeconds * 1e3,
+    createdAt: now,
+    inInstanceTimer: input.inInstanceTimer
+  });
+}
+async function sweepExpired(client) {
+  const result = { stopped: [], alreadyStopped: [], failed: [] };
+  const expired = listExpired();
+  if (expired.length === 0) return result;
+  for (const entry of expired) {
+    try {
+      const status = await getInstanceStatus(client, entry.uuid);
+      if (status === "running" || status === "starting") {
+        await powerOffInstance(client, entry.uuid);
+        const after = await getInstanceStatus(client, entry.uuid).catch(() => status);
+        if (after === "running" || after === "starting") {
+          result.failed.push({ uuid: entry.uuid, reason: `\u5173\u673A\u672A\u751F\u6548\uFF08\u72B6\u6001\u4ECD\u4E3A ${after}\uFF09` });
+          warn(
+            `${entry.name ?? entry.uuid} \u5173\u673A\u672A\u751F\u6548\uFF08\u72B6\u6001 ${after}\uFF09\uFF0C\u4FDD\u7559\u5728\u53F0\u8D26\u4E2D\uFF0C\u4E0B\u6B21\u547D\u4EE4\u4F1A\u91CD\u8BD5`
+          );
+          continue;
+        }
+        result.stopped.push(entry.uuid);
+        warn(
+          `${t("guard.sweptOne")}\uFF1A${entry.name ?? entry.uuid}\uFF08TTL ${formatDuration(entry.ttlSeconds)}\uFF09`
+        );
+      } else {
+        result.alreadyStopped.push(entry.uuid);
+      }
+      untrackInstance(entry.uuid);
+    } catch (err) {
+      const reason = err.message;
+      result.failed.push({ uuid: entry.uuid, reason });
+      debug(`\u6E05\u7406\u8D85\u65F6\u5B9E\u4F8B ${entry.uuid} \u5931\u8D25\uFF1A${reason}`);
+      if (/不存在|not found/i.test(reason)) untrackInstance(entry.uuid);
+    }
+  }
+  return result;
+}
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM,
+  ExitCode,
+  AutoDLError,
+  AuthError,
+  NotFoundError,
+  UsageError,
+  BudgetError,
+  NoStockError,
+  TimeoutError,
+  SSHError,
+  toAutoDLError,
+  isAuthError,
+  configPath,
+  readConfig,
+  writeConfig,
+  updateConfig,
+  clearToken,
+  resolveToken,
+  tryResolveToken,
+  resolveBaseUrl,
+  DEFAULT_BASE_URL,
+  redactToken,
+  AutoDLClient,
+  untrackInstance,
+  listTracked,
+  parseDuration,
+  formatDuration,
+  milliToYuan,
+  yuanToMilli,
+  formatYuan,
+  formatRate,
+  estimateCost,
+  normalizeInstance,
+  normalizeSnapshot,
+  normalizeBalance,
+  normalizeImage,
+  normalizePagination,
+  redactSnapshot,
+  createInstance,
+  listInstancesPage,
+  listAllInstances,
+  getInstanceStatus,
+  getInstanceSnapshot,
+  findInstance,
+  powerOnInstance,
+  powerOffInstance,
+  releaseInstance,
+  configureOutput,
+  isJson,
+  isVerbose,
+  note,
+  success,
+  warn,
+  debug,
+  emit,
+  emitError,
+  printTable,
+  printKeyValues,
+  stringWidth,
+  colorStatus,
+  formatBytes,
+  formatTime,
+  resolveLang,
+  setLang,
+  t,
+  waitForStatus,
+  waitForRunning,
+  waitForShutdown,
+  getCredentials,
+  withSSH,
+  execOnConnection,
+  execCommand,
+  buildTTLSnippet,
+  composeStartCommand,
+  armTTLOverSSH,
+  disarmTTLOverSSH,
+  recordTTL,
+  sweepExpired
+};
+//# sourceMappingURL=chunk-6QR4ZYQR.js.map