@minato-aqukin/autodl-cli 0.1.2 → 0.2.0

package/dist/{chunk-6QR4ZYQR.js → chunk-GHJVQKKC.js}

@@ -976,6 +976,7 @@ var waitForRunning = (client, uuid, options2) => waitForStatus(client, uuid, ["r
 var waitForShutdown = (client, uuid, options2) => waitForStatus(client, uuid, ["shutdown"], options2);
 
 // src/ssh/credentials.ts
+import { setTimeout as delay } from "timers/promises";
 import { Client } from "ssh2";
 
 // src/output/i18n.ts
@@ -1065,7 +1066,9 @@ function t(key) {
 
 // src/ssh/credentials.ts
 async function getCredentials(client, uuid, options2 = {}) {
+  assertNotAborted(options2.signal);
   let status = await getInstanceStatus(client, uuid);
+  assertNotAborted(options2.signal);
   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`, {
@@ -1082,6 +1085,7 @@ async function getCredentials(client, uuid, options2 = {}) {
       });
     }
     if (status === "shutdown") {
+      assertNotAborted(options2.signal);
       note(t("instance.poweringOn"));
       await powerOnInstance(client, uuid);
     }
@@ -1093,6 +1097,7 @@ async function getCredentials(client, uuid, options2 = {}) {
     });
   }
   const snapshot = await getInstanceSnapshot(client, uuid);
+  assertNotAborted(options2.signal);
   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`, {
@@ -1103,57 +1108,92 @@ async function getCredentials(client, uuid, options2 = {}) {
   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);
-    });
+async function connectOnce(creds, options2) {
+  assertNotAborted(options2.signal);
+  const { promise, resolve, reject } = Promise.withResolvers();
+  const conn = new Client();
+  let settled = false;
+  const settle = (err) => {
+    if (settled) return;
+    settled = true;
+    conn.off("ready", onReady);
+    if (err) {
+      conn.once("close", () => conn.off("error", onError));
+    } else {
+      conn.off("error", onError);
+    }
+    conn.off("close", onClose);
+    options2.signal?.removeEventListener("abort", onAbort);
+    if (err) reject(err);
+    else resolve(conn);
+  };
+  const onReady = () => settle();
+  const onError = (err) => {
+    if (settled) return;
+    settle(err);
+    conn.end();
+  };
+  const onClose = () => {
+    settle(new SSHError("SSH \u8FDE\u63A5\u5728\u63E1\u624B\u5B8C\u6210\u524D\u5173\u95ED"));
+    conn.off("error", onError);
+  };
+  const onAbort = () => {
+    settle(new AutoDLError("\u64CD\u4F5C\u5DF2\u53D6\u6D88"));
+    conn.destroy();
+  };
+  conn.once("ready", onReady);
+  conn.on("error", onError);
+  conn.once("close", onClose);
+  options2.signal?.addEventListener("abort", onAbort, { once: true });
+  try {
     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
+      keepaliveInterval: options2.keepaliveIntervalMs ?? 15e3
     });
-  });
+  } catch (err) {
+    onError(err instanceof Error ? err : new Error(String(err)));
+  }
+  return promise;
 }
 async function withSSH(client, uuid, fn, options2 = {}) {
+  const conn = await connectSSH(client, uuid, options2);
+  const creds = conn._creds;
+  try {
+    if (!creds) throw new SSHError("SSH \u8FDE\u63A5\u7F3A\u5C11\u51ED\u8BC1\u4E0A\u4E0B\u6587", { details: { uuid } });
+    return await fn(conn, creds);
+  } finally {
+    delete conn._creds;
+    conn.end();
+  }
+}
+async function connectSSH(client, uuid, options2 = {}) {
   let lastError;
   const attempts = Math.max(1, options2.connectAttempts ?? 3);
   for (let attempt = 0; attempt < attempts; attempt++) {
+    assertNotAborted(options2.signal);
     if (attempt > 0) {
       note(t("ssh.refreshing"));
-      await delay(RETRY_DELAYS_MS[attempt - 1] ?? RETRY_DELAYS_MS.at(-1) ?? 5e3);
+      await delay(RETRY_DELAYS_MS[attempt - 1] ?? RETRY_DELAYS_MS.at(-1) ?? 5e3, void 0, {
+        signal: options2.signal
+      });
     }
     const creds = await getCredentials(client, uuid, options2);
-    let conn;
+    assertNotAborted(options2.signal);
     try {
-      conn = await connectOnce(creds, options2);
+      const conn = await connectOnce(creds, options2);
+      conn._creds = creds;
+      return conn;
     } catch (err) {
+      assertNotAborted(options2.signal);
+      if (err instanceof Error && "level" in err && err.level === "client-authentication") {
+        throw new SSHError("SSH \u8BA4\u8BC1\u5931\u8D25\uFF0C\u8BF7\u91CD\u65B0\u83B7\u53D6\u5B9E\u4F8B\u51ED\u8BC1", { cause: 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`, {
@@ -1164,6 +1204,9 @@ async function withSSH(client, uuid, fn, options2 = {}) {
 function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
+function assertNotAborted(signal) {
+  if (signal?.aborted) throw new AutoDLError("\u64CD\u4F5C\u5DF2\u53D6\u6D88");
+}
 
 // src/ssh/exec.ts
 function buildCommand(command, options2) {
@@ -1362,6 +1405,7 @@ export {
   SSHError,
   toAutoDLError,
   isAuthError,
+  configDir,
   configPath,
   readConfig,
   writeConfig,
@@ -1420,6 +1464,8 @@ export {
   waitForShutdown,
   getCredentials,
   withSSH,
+  connectSSH,
+  assertNotAborted,
   execOnConnection,
   execCommand,
   buildTTLSnippet,
@@ -1429,4 +1475,4 @@ export {
   recordTTL,
   sweepExpired
 };
-//# sourceMappingURL=chunk-6QR4ZYQR.js.map
+//# sourceMappingURL=chunk-GHJVQKKC.js.map

package/dist/{chunk-DLCDJE6I.js → chunk-JOOIUQLJ.js}

@@ -4,7 +4,7 @@ const require = __nodeCreateRequire(import.meta.url);
 import {
   createContext,
   runOpportunisticSweep
-} from "./chunk-NBWWTYSL.js";
+} from "./chunk-VEDMEYCW.js";
 import {
   ExitCode,
   UsageError,
@@ -14,7 +14,7 @@ import {
   resolveLang,
   setLang,
   toAutoDLError
-} from "./chunk-6QR4ZYQR.js";
+} from "./chunk-GHJVQKKC.js";
 
 // src/commands/helpers.ts
 import { confirm, isCancel } from "@clack/prompts";
@@ -112,7 +112,7 @@ function assertInteractive(json) {
 }
 async function launchTui(globals) {
   assertInteractive(globals.json === true);
-  const { runTui } = await import("./app-3QXI65BE.js");
+  const { runTui } = await import("./app-V5GCG3MC.js");
   await runTui({
     ...globals.token ? { token: globals.token } : {},
     ...globals.baseUrl ? { baseUrl: globals.baseUrl } : {}
@@ -137,4 +137,4 @@ export {
   launchTui,
   registerTuiCommand
 };
-//# sourceMappingURL=chunk-DLCDJE6I.js.map
+//# sourceMappingURL=chunk-JOOIUQLJ.js.map

package/dist/{chunk-BMKVXRT7.js → chunk-MWYYK755.js}

@@ -15,10 +15,10 @@ import {
   parseCudaVersion,
   resolveGpuSpec,
   resolveRegion
-} from "./chunk-GJGHX55T.js";
+} from "./chunk-WN2CXPD2.js";
 import {
   createContext
-} from "./chunk-NBWWTYSL.js";
+} from "./chunk-VEDMEYCW.js";
 import {
   AutoDLError,
   BudgetError,
@@ -56,7 +56,7 @@ import {
   waitForShutdown,
   warn,
   withSSH
-} from "./chunk-6QR4ZYQR.js";
+} from "./chunk-GHJVQKKC.js";
 
 // src/core/endpoints/image.ts
 async function saveImage(client, instanceUuid, imageName) {
@@ -1455,4 +1455,4 @@ export {
   connectInteractive,
   formatSSHCommand
 };
-//# sourceMappingURL=chunk-BMKVXRT7.js.map
+//# sourceMappingURL=chunk-MWYYK755.js.map

package/dist/{chunk-NBWWTYSL.js → chunk-VEDMEYCW.js}

@@ -10,7 +10,7 @@ import {
   resolveToken,
   setLang,
   sweepExpired
-} from "./chunk-6QR4ZYQR.js";
+} from "./chunk-GHJVQKKC.js";
 
 // src/context.ts
 function createContext(options = {}) {
@@ -43,4 +43,4 @@ export {
   createContext,
   runOpportunisticSweep
 };
-//# sourceMappingURL=chunk-NBWWTYSL.js.map
+//# sourceMappingURL=chunk-VEDMEYCW.js.map

package/dist/{chunk-GJGHX55T.js → chunk-WN2CXPD2.js}

@@ -9,7 +9,7 @@ import {
   note,
   warn,
   yuanToMilli
-} from "./chunk-6QR4ZYQR.js";
+} from "./chunk-GHJVQKKC.js";
 
 // src/core/catalog.ts
 var GPU_SPECS = [
@@ -435,4 +435,4 @@ export {
   chooseRegions,
   VERSION
 };
-//# sourceMappingURL=chunk-GJGHX55T.js.map
+//# sourceMappingURL=chunk-WN2CXPD2.js.map

package/dist/cli.js

@@ -13,7 +13,13 @@ import {
   saveImage,
   startMcpServer,
   watchIdle
-} from "./chunk-BMKVXRT7.js";
+} from "./chunk-MWYYK755.js";
+import {
+  FileWorkspace,
+  TransferQueue,
+  connectTerminal,
+  identityFromToken
+} from "./chunk-2E2Y5GFH.js";
 import {
   BASE_IMAGES,
   DEFAULT_BASE_IMAGE,
@@ -29,7 +35,7 @@ import {
   parseCudaVersion,
   resolveGpuSpec,
   resolveRegion
-} from "./chunk-GJGHX55T.js";
+} from "./chunk-WN2CXPD2.js";
 import {
   action,
   bareAction,
@@ -37,10 +43,11 @@ import {
   globalsOf,
   lazyAction,
   registerTuiCommand
-} from "./chunk-DLCDJE6I.js";
-import "./chunk-NBWWTYSL.js";
+} from "./chunk-JOOIUQLJ.js";
+import "./chunk-VEDMEYCW.js";
 import {
   AutoDLClient,
+  DEFAULT_BASE_URL,
   ExitCode,
   UsageError,
   armTTLOverSSH,
@@ -76,7 +83,9 @@ import {
   recordTTL,
   redactToken,
   releaseInstance,
+  resolveBaseUrl,
   resolveLang,
+  resolveToken,
   setLang,
   success,
   sweepExpired,
@@ -87,7 +96,7 @@ import {
   waitForRunning,
   waitForShutdown,
   warn
-} from "./chunk-6QR4ZYQR.js";
+} from "./chunk-GHJVQKKC.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -356,6 +365,250 @@ function registerDeployCommand(program) {
   );
 }
 
+// src/commands/files.ts
+import { createHash } from "crypto";
+function queueNamespace(token, baseUrl) {
+  const identity = identityFromToken(token);
+  const account = [identity.tenant, identity.uid ?? identity.uuid ?? token];
+  return createHash("sha256").update(JSON.stringify([(baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, ""), account])).digest("hex");
+}
+function queueFor(context, command) {
+  const globals = globalsOf(command);
+  const resolved = resolveToken(globals.token);
+  const baseUrl = resolveBaseUrl(globals.baseUrl);
+  const queue = new TransferQueue(context.client, queueNamespace(resolved.token, baseUrl));
+  let released = false;
+  return {
+    queue,
+    release: async () => {
+      if (!released) {
+        released = true;
+        await queue.dispose();
+      }
+    }
+  };
+}
+async function withWorkspace(context, id, fn) {
+  const workspace = new FileWorkspace(context.client, id);
+  try {
+    return await fn(workspace);
+  } finally {
+    workspace.dispose();
+  }
+}
+async function ensureStarted(context, id, start) {
+  if (start) await getCredentials(context.client, id, { autoStart: true });
+}
+var STATE_LABEL = {
+  queued: "\u6392\u961F",
+  running: "\u4F20\u8F93\u4E2D",
+  conflict: "\u5F85\u786E\u8BA4",
+  paused: "\u5DF2\u6682\u505C",
+  completed: "\u5B8C\u6210",
+  cancelled: "\u5DF2\u53D6\u6D88"
+};
+function registerFileCommands(program) {
+  const files = program.command("files").description("\u6D4F\u89C8\u4E0E\u7BA1\u7406\u5B9E\u4F8B\u6587\u4EF6\uFF08SFTP\uFF0C\u8FDE\u63A5\u590D\u7528\uFF09");
+  files.command("ls <id> [remote]").description("\u5217\u51FA\u8FDC\u7A0B\u76EE\u5F55\uFF08\u5F53\u524D\u5C42\uFF0C\u65E0\u9012\u5F52\uFF09").option("--start", "\u5B9E\u4F8B\u672A\u8FD0\u884C\u65F6\u81EA\u52A8\u5F00\u673A", false).action(
+    action(
+      async (context, id, remote, options) => {
+        const dir = remote ?? "/root/autodl-tmp";
+        const entries = await withWorkspace(context, id, async (workspace) => {
+          await ensureStarted(context, id, options.start);
+          return workspace.list("remote", dir);
+        });
+        emit({ uuid: id, path: dir, entries }, () => {
+          for (const entry of entries) {
+            printKeyValues([[entry.name, `${entry.kind} ${entry.size} ${entry.path}`]]);
+          }
+          if (entries.length === 0) note("\u7A7A\u76EE\u5F55");
+        });
+        return 0;
+      }
+    )
+  );
+  files.command("mkdir <id> <remote>").description("\u5728\u5B9E\u4F8B\u4E0A\u521B\u5EFA\u76EE\u5F55").option("--start", "\u5B9E\u4F8B\u672A\u8FD0\u884C\u65F6\u81EA\u52A8\u5F00\u673A", false).action(
+    action(async (context, id, remote, options) => {
+      await withWorkspace(context, id, async (workspace) => {
+        await ensureStarted(context, id, options.start);
+        return workspace.mkdir("remote", remote);
+      });
+      emit({ uuid: id, path: remote, created: true }, () => success(`\u5DF2\u521B\u5EFA ${remote}`));
+      return 0;
+    })
+  );
+  files.command("mv <id> <from> <to>").description("\u5728\u5B9E\u4F8B\u4E0A\u6539\u540D\u6216\u79FB\u52A8\uFF08\u4E0D\u8986\u76D6\u5DF2\u5B58\u5728\u76EE\u6807\uFF09").option("--start", "\u5B9E\u4F8B\u672A\u8FD0\u884C\u65F6\u81EA\u52A8\u5F00\u673A", false).action(
+    action(async (context, id, from, to, options) => {
+      await withWorkspace(context, id, async (workspace) => {
+        await ensureStarted(context, id, options.start);
+        return workspace.rename("remote", from, to);
+      });
+      emit({ uuid: id, from, to, moved: true }, () => success(`\u5DF2\u79FB\u52A8 ${from} \u2192 ${to}`));
+      return 0;
+    })
+  );
+  files.command("rm <id> <remote>").description("\u5220\u9664\u5B9E\u4F8B\u6587\u4EF6\u6216\u76EE\u5F55\uFF08\u9012\u5F52\uFF0C\u4E0D\u53EF\u6062\u590D\uFF09").option("--yes", "\u786E\u8BA4\u5220\u9664", false).option("--start", "\u5B9E\u4F8B\u672A\u8FD0\u884C\u65F6\u81EA\u52A8\u5F00\u673A", false).action(
+    action(
+      async (context, id, remote, options) => {
+        const confirmed = await confirmDestructive(
+          `\u6C38\u4E45\u5220\u9664\u5B9E\u4F8B\u6587\u4EF6 ${id}:${remote}`,
+          options.yes
+        );
+        if (!confirmed) {
+          emit({ uuid: id, path: remote, removed: false, cancelled: true }, () => note("\u5DF2\u53D6\u6D88"));
+          return 0;
+        }
+        await withWorkspace(context, id, async (workspace) => {
+          await ensureStarted(context, id, options.start);
+          return workspace.remove("remote", remote);
+        });
+        emit({ uuid: id, path: remote, removed: true }, () => success(`\u5DF2\u5220\u9664 ${remote}`));
+        return 0;
+      }
+    )
+  );
+  const queue = program.command("queue").description("\u4E32\u884C\u4F20\u8F93\u961F\u5217\uFF08\u4E0E\u770B\u677F\u5171\u7528\u540C\u4E00\u961F\u5217\uFF09");
+  queue.command("add <id> <source> <destination>").description("\u52A0\u5165\u4E0A\u4F20/\u4E0B\u8F7D\u4EFB\u52A1\uFF08\u6765\u6E90\u5728\u672C\u5730\u5219\u4E0A\u4F20\uFF0C\u5728\u8FDC\u7AEF\u9700 --download\uFF09").option("--download", "\u4ECE\u5B9E\u4F8B\u4E0B\u8F7D\u5230\u672C\u5730", false).option("--sync", "\u5355\u5411\u589E\u91CF\u540C\u6B65\uFF0C\u4E0D\u5220\u9664\u76EE\u6807\u72EC\u6709\u6587\u4EF6", false).option("--checksum", "SHA-256 \u5185\u5BB9\u6821\u9A8C", false).option("--wait", "\u7B49\u5F85\u4EFB\u52A1\u5B8C\u6210", false).action(
+    action(
+      async (context, id, source, destination, options, command) => {
+        const { queue: transferQueue, release } = queueFor(context, command);
+        try {
+          const jobId = transferQueue.enqueue({
+            uuid: id,
+            direction: options.download ? "download" : "upload",
+            sources: [source],
+            destination,
+            sync: options.sync,
+            checksum: options.checksum
+          });
+          if (options.wait) {
+            const done = await waitForJob(transferQueue, jobId);
+            emit(
+              { jobId, ...done },
+              () => success(`\u4EFB\u52A1 ${jobId}\uFF1A${STATE_LABEL[done.state] ?? done.state}`)
+            );
+            return 0;
+          }
+          emit({ jobId, uuid: id }, () => success(`\u5DF2\u52A0\u5165\u961F\u5217\uFF1A${jobId}`));
+          return 0;
+        } finally {
+          await release();
+        }
+      }
+    )
+  );
+  queue.command("ls").description("\u5217\u51FA\u5F53\u524D\u8D26\u53F7\u7684\u4F20\u8F93\u4EFB\u52A1").action(
+    action(async (context, _options, command) => {
+      const { queue: transferQueue, release } = queueFor(context, command);
+      try {
+        const jobs = transferQueue.snapshot().map((job) => ({
+          id: job.request.id,
+          uuid: job.request.uuid,
+          direction: job.request.direction,
+          sources: job.request.sources,
+          destination: job.request.destination,
+          sync: job.request.sync,
+          checksum: job.request.checksum,
+          state: job.state,
+          ...job.error !== void 0 ? { error: job.error } : {},
+          ...job.result ? { result: job.result } : {}
+        }));
+        emit({ jobs }, () => {
+          if (jobs.length === 0) {
+            note("\u961F\u5217\u4E3A\u7A7A");
+            return;
+          }
+          for (const job of jobs) {
+            printKeyValues([
+              [
+                job.id,
+                `${job.direction} ${STATE_LABEL[job.state] ?? job.state} \u2192 ${job.destination}`
+              ]
+            ]);
+          }
+        });
+        return 0;
+      } finally {
+        await release();
+      }
+    })
+  );
+  queue.command("resume <jobId>").description("\u6062\u590D\u5DF2\u6682\u505C/\u5DF2\u53D6\u6D88\u7684\u4EFB\u52A1\uFF08\u9700\u5B9E\u4F8B\u8FD0\u884C\u4E2D\uFF0C\u4E0D\u81EA\u52A8\u5F00\u673A\uFF09").action(
+    action(async (context, jobId, _options, command) => {
+      const { queue: transferQueue, release } = queueFor(context, command);
+      try {
+        transferQueue.resume(jobId);
+        emit({ jobId, resumed: true }, () => success(`\u5DF2\u6062\u590D ${jobId}`));
+        return 0;
+      } finally {
+        await release();
+      }
+    })
+  );
+  queue.command("cancel <jobId>").description("\u53D6\u6D88\u6392\u961F/\u4F20\u8F93\u4E2D\u7684\u4EFB\u52A1\uFF08\u4FDD\u7559\u7EED\u4F20\u6570\u636E\uFF09").action(
+    action(async (context, jobId, _options, command) => {
+      const { queue: transferQueue, release } = queueFor(context, command);
+      try {
+        transferQueue.cancel(jobId);
+        emit({ jobId, cancelled: true }, () => success(`\u5DF2\u53D6\u6D88 ${jobId}`));
+        return 0;
+      } finally {
+        await release();
+      }
+    })
+  );
+  queue.command("resolve <jobId> <choice>").description("\u5904\u7406\u4EFB\u52A1\u7684\u6587\u4EF6\u51B2\u7A81\uFF1Aoverwrite / skip / keep-both").option("--all", "\u5E94\u7528\u4E8E\u672C\u4EFB\u52A1\u5176\u4F59\u51B2\u7A81", false).action(
+    action(
+      async (context, jobId, choice, options, command) => {
+        if (choice !== "overwrite" && choice !== "skip" && choice !== "keep-both") {
+          throw new UsageError("choice \u5FC5\u987B\u662F overwrite / skip / keep-both");
+        }
+        const { queue: transferQueue, release } = queueFor(context, command);
+        try {
+          transferQueue.resolveConflict(jobId, { choice, applyToAll: options.all });
+          emit(
+            { jobId, choice, applyToAll: options.all },
+            () => success(`\u5DF2\u5904\u7406\u51B2\u7A81\uFF1A${choice}`)
+          );
+          return 0;
+        } finally {
+          await release();
+        }
+      }
+    )
+  );
+}
+async function waitForJob(queue, jobId) {
+  const { promise, resolve } = Promise.withResolvers();
+  const done = (state, error) => resolve(error === void 0 ? { state } : { state, error });
+  const check = () => {
+    const job = queue.snapshot().find((entry) => entry.request.id === jobId);
+    if (!job) {
+      done("missing", "\u4EFB\u52A1\u4E0D\u5B58\u5728");
+      return true;
+    }
+    if (job.state === "completed" || job.state === "cancelled") {
+      done(job.state, job.error);
+      return true;
+    }
+    if (job.state === "paused") {
+      done(job.state, job.error ?? "\u4EFB\u52A1\u5DF2\u6682\u505C");
+      return true;
+    }
+    if (job.state === "conflict" && isJson()) {
+      done(job.state, job.error ?? "\u4EFB\u52A1\u7B49\u5F85\u51B2\u7A81\u786E\u8BA4\uFF08\u975E\u4EA4\u4E92\u6A21\u5F0F\u65E0\u6CD5\u56DE\u7B54\uFF09");
+      return true;
+    }
+    return false;
+  };
+  if (check()) return promise;
+  const unsubscribe = queue.subscribe(() => {
+    if (check()) unsubscribe();
+  });
+  if (check()) unsubscribe();
+  return promise;
+}
+
 // src/commands/guard.ts
 import pc4 from "picocolors";
 function registerGuardCommands(program) {
@@ -803,24 +1056,37 @@ function registerRunCommand(program) {
 // 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]
-          ]);
+  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).option("--auto-auth", "\u4F7F\u7528\u5B9E\u4F8B\u5BC6\u7801\u81EA\u52A8\u8BA4\u8BC1\uFF08\u72EC\u5360\u5F53\u524D\u7EC8\u7AEF\uFF0C\u4E0D\u8BFB\u53D6 OpenSSH \u914D\u7F6E\uFF09", 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);
+        if (options.autoAuth) {
+          if (isJson() || !process.stdin.isTTY || !process.stdout.isTTY) {
+            throw new UsageError("--auto-auth \u9700\u8981\u4EA4\u4E92\u5F0F\u7EC8\u7AEF\uFF0C\u4E0D\u652F\u6301 --json");
+          }
+          if (extraArgs.length) {
+            throw new UsageError(
+              "--auto-auth \u4E0D\u63A5\u53D7 OpenSSH \u53C2\u6570\uFF1B\u7AEF\u53E3\u8F6C\u53D1\u7B49\u573A\u666F\u8BF7\u4F7F\u7528\u666E\u901A autodl ssh"
+            );
+          }
+          return connectTerminal(context.client, id, { autoStart: options.start });
+        }
+        return connectInteractive(context.client, id, {
+          autoStart: options.start,
+          extraArgs
         });
-        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(
@@ -983,6 +1249,7 @@ function buildProgram() {
   registerAccountCommands(program);
   registerInstanceCommands(program);
   registerSSHCommands(program);
+  registerFileCommands(program);
   registerRunCommand(program);
   registerDeployCommand(program);
   registerGuardCommands(program);
@@ -1021,7 +1288,7 @@ function shouldLaunchBareTui(argv) {
 async function main(argv = process.argv) {
   if (shouldLaunchBareTui(argv)) {
     try {
-      const { launchTui } = await import("./tui-2JGNYYRA.js");
+      const { launchTui } = await import("./tui-ZT5ZBVSQ.js");
       await launchTui({});
       return;
     } catch (err) {