@minato-aqukin/autodl-cli 0.1.2 → 0.2.0

package/dist/chunk-2E2Y5GFH.js

@@ -0,0 +1,1704 @@
+#!/usr/bin/env node
+import { createRequire as __nodeCreateRequire } from "node:module";
+const require = __nodeCreateRequire(import.meta.url);
+import {
+  AutoDLError,
+  SSHError,
+  UsageError,
+  assertNotAborted,
+  configDir,
+  connectSSH,
+  withSSH
+} from "./chunk-GHJVQKKC.js";
+
+// src/ssh/files.ts
+import { createHash } from "crypto";
+import { createReadStream, createWriteStream } from "fs";
+import * as fs from "fs/promises";
+import { basename, dirname, join, parse, posix, resolve } from "path";
+import { Transform, Writable } from "stream";
+import { pipeline } from "stream/promises";
+import { z } from "zod";
+function missing(err) {
+  return typeof err === "object" && err !== null && "code" in err && (err.code === "ENOENT" || err.code === 2);
+}
+function interrupted() {
+  return Object.assign(new Error("SSH transport disconnected"), { code: "ECONNRESET" });
+}
+function kind(stats) {
+  return stats.isSymbolicLink() ? "symlink" : stats.isDirectory() ? "directory" : stats.isFile() ? "file" : "other";
+}
+function kindFromMode(mode) {
+  const fileType = mode & 61440;
+  if (fileType === 40960) return "symlink";
+  if (fileType === 16384) return "directory";
+  if (fileType === 32768) return "file";
+  return "other";
+}
+function fromAttrs(attrs) {
+  return {
+    kind: kindFromMode(attrs.mode),
+    size: attrs.size,
+    mtime: attrs.mtime * 1e3
+  };
+}
+var localIO = {
+  async stat(path) {
+    try {
+      const s = await fs.lstat(path);
+      return { kind: kind(s), size: s.size, mtime: s.mtimeMs };
+    } catch (err) {
+      if (missing(err)) return null;
+      throw err;
+    }
+  },
+  async entries(path) {
+    const names = await fs.readdir(path, { withFileTypes: true });
+    const out = [];
+    for (const entry of names) {
+      if (entry.name === "." || entry.name === "..") continue;
+      if (entry.isSymbolicLink())
+        out.push({ name: entry.name, kind: "symlink", size: 0, mtime: 0 });
+      else if (entry.isDirectory())
+        out.push({ name: entry.name, kind: "directory", size: 0, mtime: 0 });
+      else if (entry.isFile()) {
+        const s = await fs.lstat(join(path, entry.name));
+        out.push({ name: entry.name, kind: "file", size: s.size, mtime: s.mtimeMs });
+      } else out.push({ name: entry.name, kind: "other", size: 0, mtime: 0 });
+    }
+    return out;
+  },
+  async mkdir(path) {
+    await fs.mkdir(path);
+  },
+  async rename(from, to, overwrite) {
+    if (overwrite) await fs.rename(from, to);
+    else {
+      const s = await fs.lstat(from);
+      if (s.isFile()) {
+        await fs.link(from, to);
+        await fs.unlink(from);
+      } else {
+        if (await localIO.stat(to)) throw new Error(`\u76EE\u6807\u5DF2\u5B58\u5728\uFF1A${to}`);
+        await fs.rename(from, to);
+      }
+    }
+  },
+  unlink: (path) => fs.unlink(path),
+  rmdir: (path) => fs.rmdir(path),
+  async times(path, mtime) {
+    await fs.utimes(path, mtime / 1e3, mtime / 1e3);
+  },
+  read: (path, start = 0, end) => createReadStream(path, { start, ...end === void 0 ? {} : { end } }),
+  write: (path, start, resume) => createWriteStream(path, { flags: resume ? "r+" : "wx", start, mode: 384 })
+};
+var RemoteIO = class {
+  constructor(conn, sftp, signal) {
+    this.conn = conn;
+    this.sftp = sftp;
+    this.signal = signal;
+    conn.on("close", this.onClose);
+    conn.on("error", this.onError);
+    sftp.on("close", this.onClose);
+    sftp.on("error", this.onError);
+    signal?.addEventListener("abort", this.onAbort, { once: true });
+  }
+  conn;
+  sftp;
+  signal;
+  failure = null;
+  pending = /* @__PURE__ */ new Set();
+  streams = /* @__PURE__ */ new Set();
+  onClose = () => this.fail(interrupted());
+  onError = (err) => this.fail(err);
+  onAbort = () => this.fail(new AutoDLError("\u64CD\u4F5C\u5DF2\u53D6\u6D88"));
+  fail(err) {
+    this.failure ??= err;
+    for (const reject of this.pending) reject(err);
+    for (const stream of this.streams) stream.destroy(err);
+  }
+  close() {
+    this.signal?.removeEventListener("abort", this.onAbort);
+    this.conn.off("close", this.onClose);
+    this.conn.off("error", this.onError);
+    this.sftp.off("close", this.onClose);
+    this.sftp.off("error", this.onError);
+    this.sftp.end();
+  }
+  call(start) {
+    if (this.failure) return Promise.reject(this.failure);
+    if (this.signal?.aborted) return Promise.reject(new AutoDLError("\u64CD\u4F5C\u5DF2\u53D6\u6D88"));
+    const { promise, resolve: done, reject } = Promise.withResolvers();
+    const fail = (err) => {
+      this.pending.delete(fail);
+      reject(err);
+    };
+    this.pending.add(fail);
+    try {
+      start((err, value) => {
+        this.pending.delete(fail);
+        if (err) reject(err);
+        else done(value);
+      });
+    } catch (err) {
+      fail(err instanceof Error ? err : new Error(String(err)));
+    }
+    return promise;
+  }
+  async stat(path) {
+    try {
+      const stats = await this.call((cb) => this.sftp.lstat(path, cb));
+      return { kind: kind(stats), size: stats.size, mtime: stats.mtime * 1e3 };
+    } catch (err) {
+      if (missing(err)) return null;
+      throw err;
+    }
+  }
+  async entries(path) {
+    const list = await this.call((cb) => this.sftp.readdir(path, cb));
+    return list.filter((entry) => entry.filename !== "." && entry.filename !== "..").map((entry) => ({ name: entry.filename, ...fromAttrs(entry.attrs) }));
+  }
+  async mkdir(path) {
+    await this.call((cb) => this.sftp.mkdir(path, (err) => cb(err, void 0)));
+  }
+  async rename(from, to, overwrite) {
+    await this.call((cb) => {
+      if (overwrite) this.sftp.ext_openssh_rename(from, to, (err) => cb(err, void 0));
+      else this.sftp.rename(from, to, (err) => cb(err, void 0));
+    });
+  }
+  async unlink(path) {
+    await this.call((cb) => this.sftp.unlink(path, (err) => cb(err, void 0)));
+  }
+  async rmdir(path) {
+    await this.call((cb) => this.sftp.rmdir(path, (err) => cb(err, void 0)));
+  }
+  async times(path, mtime) {
+    await this.call(
+      (cb) => this.sftp.utimes(path, mtime / 1e3, mtime / 1e3, (err) => cb(err, void 0))
+    );
+  }
+  track(stream) {
+    this.streams.add(stream);
+    stream.on("error", this.onError);
+    stream.once("close", () => this.streams.delete(stream));
+    if (this.failure) queueMicrotask(() => stream.destroy(this.failure ?? interrupted()));
+    return stream;
+  }
+  read(path, start = 0, end) {
+    return this.track(
+      this.sftp.createReadStream(path, { start, ...end === void 0 ? {} : { end } })
+    );
+  }
+  write(path, start, resume) {
+    return this.track(
+      this.sftp.createWriteStream(path, { flags: resume ? "r+" : "wx", start, mode: 384 })
+    );
+  }
+};
+async function openSftp(client, uuid, signal) {
+  const conn = await connectSSH(client, uuid, {
+    ...signal ? { signal } : {},
+    connectAttempts: 1
+  });
+  assertNotAborted(signal);
+  const { promise, resolve: done, reject } = Promise.withResolvers();
+  const lost = () => reject(interrupted());
+  const abort = () => {
+    reject(new AutoDLError("\u64CD\u4F5C\u5DF2\u53D6\u6D88"));
+    conn.end();
+  };
+  conn.once("close", lost);
+  conn.once("error", reject);
+  signal?.addEventListener("abort", abort, { once: true });
+  conn.sftp((err, handle) => {
+    if (err) reject(err);
+    else done(handle);
+  });
+  try {
+    const handle = await promise;
+    const io = new RemoteIO(conn, handle, signal);
+    assertNotAborted(signal);
+    return { conn, io };
+  } catch (err) {
+    conn.off("close", lost);
+    conn.off("error", reject);
+    signal?.removeEventListener("abort", abort);
+    conn.end();
+    throw err;
+  }
+}
+async function remote(client, uuid, fn, signal) {
+  const { conn, io } = await openSftp(client, uuid, signal);
+  try {
+    return await fn(io);
+  } finally {
+    io.close();
+    conn.end();
+  }
+}
+function fullPath(side, path) {
+  if (!path.trim() || path.includes("\0")) throw new Error("\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A\u6216\u5305\u542B NUL");
+  return side === "local" ? resolve(path) : posix.resolve("/", path);
+}
+function safeName(name, local) {
+  if (!name || name === "." || name === ".." || name.includes("/") || name.includes("\0") || local && process.platform === "win32" && (/[\\:<>"|?*]/.test(name) || /[ .]$/.test(name) || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(name))) {
+    throw new Error(`\u4E0D\u5B89\u5168\u6216\u5F53\u524D\u5E73\u53F0\u4E0D\u652F\u6301\u7684\u6587\u4EF6\u540D\uFF1A${JSON.stringify(name)}`);
+  }
+}
+async function ensureDir(io, path, parent) {
+  const info = await io.stat(path);
+  if (info) {
+    if (info.kind !== "directory") throw new Error(`\u76EE\u6807\u4E0D\u662F\u666E\u901A\u76EE\u5F55\uFF08\u4E0D\u8DDF\u968F\u7B26\u53F7\u94FE\u63A5\uFF09\uFF1A${path}`);
+    return;
+  }
+  const up = parent(path);
+  if (up === path) throw new Error(`\u76EE\u5F55\u4E0D\u53EF\u8BBF\u95EE\uFF1A${path}`);
+  await ensureDir(io, up, parent);
+  try {
+    await io.mkdir(path);
+  } catch (err) {
+    if ((await io.stat(path))?.kind !== "directory") throw err;
+  }
+}
+async function digest(io, path, signal, end) {
+  assertNotAborted(signal);
+  const hash = createHash("sha256");
+  await pipeline(
+    io.read(path, 0, end),
+    new Writable({
+      write(chunk, _encoding, done) {
+        hash.update(chunk);
+        done();
+      }
+    }),
+    { signal }
+  );
+  return hash.digest("hex");
+}
+function sameVersion(a, b) {
+  return a?.kind === b?.kind && a?.size === b?.size && a?.mtime === b?.mtime;
+}
+var CheckpointSchema = z.object({
+  version: z.literal(1),
+  key: z.string(),
+  choice: z.enum(["overwrite", "skip", "keep-both"]).optional(),
+  files: z.record(
+    z.object({ size: z.number(), mtime: z.number(), target: z.string(), complete: z.boolean() })
+  )
+});
+var FileWorkspace = class {
+  constructor(client, uuid) {
+    this.client = client;
+    this.uuid = uuid;
+  }
+  client;
+  uuid;
+  session = null;
+  connecting = null;
+  disposed = false;
+  use(side, fn) {
+    if (side === "local") return fn(localIO);
+    return this.withSession((io) => fn(io));
+  }
+  /**
+   * One SFTP connection for all short browsing operations. Directory contents
+   * are still read live on every call — only the TCP handshake and SSH
+   * authentication are reused. A dead connection is dropped and the next
+   * operation reconnects transparently. Long transfers keep their own
+   * connection so browsing and transfers never block each other.
+   */
+  async withSession(fn) {
+    if (this.disposed) throw new Error("\u6587\u4EF6\u4F1A\u8BDD\u5DF2\u5173\u95ED");
+    const live = this.session ?? await this.connect();
+    try {
+      return await fn(live.io);
+    } catch (err) {
+      this.drop(live);
+      throw err;
+    }
+  }
+  async connect() {
+    if (this.session) return this.session;
+    this.connecting ??= openSftp(this.client, this.uuid).then(
+      (session) => {
+        this.session = session;
+        this.connecting = null;
+        session.conn.once("close", () => this.drop(session));
+        return session;
+      },
+      (err) => {
+        this.connecting = null;
+        throw err;
+      }
+    );
+    return this.connecting;
+  }
+  drop(session) {
+    if (this.session !== session) return;
+    this.session = null;
+    try {
+      session.io.close();
+    } catch {
+    }
+    try {
+      session.conn.end();
+    } catch {
+    }
+  }
+  /** Release the browsing connection; safe to call more than once. */
+  dispose() {
+    this.disposed = true;
+    this.connecting = null;
+    const session = this.session;
+    this.session = null;
+    if (!session) return;
+    try {
+      session.io.close();
+    } catch {
+    }
+    try {
+      session.conn.end();
+    } catch {
+    }
+  }
+  async list(side, path) {
+    const root = fullPath(side, path);
+    const paths = side === "local" ? { join } : posix;
+    return this.use(side, async (io) => {
+      if ((await io.stat(root))?.kind !== "directory") throw new Error(`\u4E0D\u662F\u666E\u901A\u76EE\u5F55\uFF1A${root}`);
+      const entries = [];
+      for (const item of await io.entries(root)) {
+        safeName(item.name, side === "local");
+        const { name, ...info } = item;
+        entries.push({ name, path: paths.join(root, name), ...info });
+      }
+      return entries.sort(
+        (a, b) => Number(b.kind === "directory") - Number(a.kind === "directory") || a.name.localeCompare(b.name)
+      );
+    });
+  }
+  async mkdir(side, path) {
+    await this.use(
+      side,
+      (io) => ensureDir(io, fullPath(side, path), side === "local" ? dirname : posix.dirname)
+    );
+  }
+  async rename(side, from, to) {
+    const source = fullPath(side, from), target = fullPath(side, to);
+    if (source === target) return;
+    const root = side === "local" ? parse(source).root : "/";
+    if (source === root) throw new Error("\u4E0D\u80FD\u79FB\u52A8\u6587\u4EF6\u7CFB\u7EDF\u6839\u76EE\u5F55");
+    await this.use(side, async (io) => {
+      if (await io.stat(target)) throw new Error(`\u76EE\u6807\u5DF2\u5B58\u5728\uFF0C\u672A\u8986\u76D6\uFF1A${target}`);
+      await io.rename(source, target, false);
+    });
+  }
+  async remove(side, path) {
+    if (path === "." || path === "..") throw new Error("\u4E0D\u80FD\u5220\u9664\u5F53\u524D\u4F4D\u7F6E\u6216\u7236\u76EE\u5F55");
+    const root = fullPath(side, path);
+    if (root === (side === "local" ? parse(root).root : "/"))
+      throw new Error("\u4E0D\u80FD\u5220\u9664\u6587\u4EF6\u7CFB\u7EDF\u6839\u76EE\u5F55");
+    await this.use(side, async (io) => {
+      const walk = async (current) => {
+        const info = await io.stat(current);
+        if (!info) throw new Error(`\u8DEF\u5F84\u4E0D\u5B58\u5728\uFF1A${current}`);
+        if (info.kind === "directory") {
+          for (const item of await io.entries(current)) {
+            safeName(item.name, side === "local");
+            await walk(
+              side === "local" ? join(current, item.name) : posix.join(current, item.name)
+            );
+          }
+          await io.rmdir(current);
+        } else await io.unlink(current);
+      };
+      await walk(root);
+    });
+  }
+  async transfer(request, callbacks, signal) {
+    if (request.uuid !== this.uuid || !/^[\da-f-]{36}$/i.test(request.id) || !request.sources.length)
+      throw new Error("\u4F20\u8F93\u4EFB\u52A1\u6807\u8BC6\u6216\u6765\u6E90\u65E0\u6548");
+    assertNotAborted(signal);
+    const upload = request.direction === "upload";
+    const sourcePaths = upload ? { join, dirname, basename } : posix;
+    const targetPaths = upload ? posix : { join, dirname, basename };
+    const destination = fullPath(upload ? "remote" : "local", request.destination);
+    const sources = request.sources.map((p) => fullPath(upload ? "local" : "remote", p));
+    const key = createHash("sha256").update(
+      JSON.stringify([this.uuid, upload, sources, destination, request.sync, request.checksum])
+    ).digest("hex");
+    const metadataDir = join(configDir(), "transfers", "partials");
+    const metadataPath = join(metadataDir, `${request.id}.json`);
+    let checkpoint = { version: 1, key, files: {} };
+    try {
+      checkpoint = CheckpointSchema.parse(JSON.parse(await fs.readFile(metadataPath, "utf8")));
+    } catch (err) {
+      if (!missing(err)) throw new Error(`\u7EED\u4F20\u8BB0\u5F55\u4E0D\u53EF\u8BFB\u53D6\uFF1A${metadataPath}`, { cause: err });
+    }
+    if (checkpoint.key !== key) throw new Error("\u7EED\u4F20\u4EFB\u52A1\u8DEF\u5F84\u6216\u9009\u9879\u5DF2\u6539\u53D8\uFF0C\u8BF7\u521B\u5EFA\u65B0\u4EFB\u52A1");
+    const save = async () => {
+      await fs.mkdir(metadataDir, { recursive: true, mode: 448 });
+      const temporary = `${metadataPath}.${process.pid}.tmp`;
+      await fs.writeFile(temporary, JSON.stringify(checkpoint), { mode: 384 });
+      await fs.rename(temporary, metadataPath);
+    };
+    await save();
+    return remote(
+      this.client,
+      this.uuid,
+      async (remoteIO) => {
+        const source = upload ? localIO : remoteIO;
+        const target = upload ? remoteIO : localIO;
+        const files = [];
+        const directories = [];
+        const skipped = [];
+        const destinations = /* @__PURE__ */ new Set();
+        const walk = async (from, to) => {
+          assertNotAborted(signal);
+          if (destinations.has(to)) throw new Error(`\u591A\u4E2A\u6765\u6E90\u6620\u5C04\u5230\u540C\u4E00\u76EE\u6807\uFF1A${to}`);
+          destinations.add(to);
+          const info = await source.stat(from);
+          if (!info) throw new Error(`\u6765\u6E90\u4E0D\u5B58\u5728\uFF1A${from}`);
+          if (info.kind === "symlink" || info.kind === "other") {
+            skipped.push(from);
+            return;
+          }
+          if (info.kind === "directory") {
+            directories.push(to);
+            for (const item of await source.entries(from)) {
+              safeName(item.name, !upload);
+              await walk(sourcePaths.join(from, item.name), targetPaths.join(to, item.name));
+            }
+          } else files.push({ source: from, target: to, info });
+        };
+        for (const path of sources) {
+          const name = sourcePaths.basename(path);
+          safeName(name, !upload);
+          await walk(path, targetPaths.join(destination, name));
+        }
+        await ensureDir(target, destination, targetPaths.dirname);
+        for (const dir of directories) {
+          assertNotAborted(signal);
+          await ensureDir(target, dir, targetPaths.dirname);
+        }
+        const total = files.reduce((sum, file) => sum + file.info.size, 0);
+        let transferred = 0, filesDone = 0, copied = 0, bytes = 0, sessionBytes = 0;
+        const started = Date.now();
+        const progress = (file) => callbacks.onProgress({
+          file,
+          transferred,
+          total,
+          filesDone,
+          filesTotal: files.length,
+          bytesPerSecond: sessionBytes * 1e3 / Math.max(1, Date.now() - started)
+        });
+        for (const file of files) {
+          assertNotAborted(signal);
+          const id = createHash("sha256").update(JSON.stringify([file.source, file.target])).digest("hex");
+          let saved = checkpoint.files[id];
+          let output = file.target;
+          if (saved && (targetPaths.dirname(saved.target) !== targetPaths.dirname(output) || !targetPaths.basename(saved.target).startsWith(targetPaths.basename(output))))
+            throw new Error("\u7EED\u4F20\u76EE\u6807\u4E0D\u5728\u539F\u4EFB\u52A1\u76EE\u5F55\u5185");
+          if (saved) output = saved.target;
+          let existing = await target.stat(output);
+          if (existing && existing.kind !== "file")
+            throw new Error(`\u76EE\u6807\u4E0D\u662F\u666E\u901A\u6587\u4EF6\uFF0C\u672A\u8986\u76D6\uFF1A${output}`);
+          const unchanged = existing?.size === file.info.size && Math.floor(existing.mtime / 1e3) === Math.floor(file.info.mtime / 1e3);
+          let equal = unchanged;
+          if (existing && request.checksum && (request.sync || saved?.complete))
+            equal = existing.size === file.info.size && await digest(source, file.source, signal) === await digest(target, output, signal);
+          if ((request.sync || saved?.complete && saved.size === file.info.size && saved.mtime === file.info.mtime) && equal) {
+            transferred += file.info.size;
+            filesDone++;
+            skipped.push(file.source);
+            progress(file.source);
+            continue;
+          }
+          if (!request.sync && existing && !saved) {
+            const resolution = checkpoint.choice ? { choice: checkpoint.choice, applyToAll: true } : await callbacks.onConflict({
+              source: file.source,
+              destination: output,
+              sourceSize: file.info.size,
+              destinationSize: existing.size
+            });
+            assertNotAborted(signal);
+            if (resolution.applyToAll) {
+              checkpoint.choice = resolution.choice;
+              await save();
+            }
+            if (resolution.choice === "skip") {
+              skipped.push(file.source);
+              transferred += file.info.size;
+              filesDone++;
+              progress(file.source);
+              continue;
+            }
+            if (resolution.choice === "keep-both") {
+              let n = 1;
+              while (await target.stat(`${file.target} (${n})`)) n++;
+              output = `${file.target} (${n})`;
+              existing = null;
+            }
+          }
+          const temporary = targetPaths.join(
+            targetPaths.dirname(output),
+            `.autodl-${request.id}-${id.slice(0, 16)}.part`
+          );
+          await ensureDir(target, targetPaths.dirname(output), targetPaths.dirname);
+          let partial = await target.stat(temporary);
+          if (partial && partial.kind !== "file")
+            throw new Error(`\u7EED\u4F20\u4E34\u65F6\u8DEF\u5F84\u4E0D\u662F\u666E\u901A\u6587\u4EF6\uFF1A${temporary}`);
+          const versionMatches = saved?.size === file.info.size && saved.mtime === file.info.mtime;
+          let offset = versionMatches && partial ? partial.size : 0;
+          if (offset > file.info.size) offset = 0;
+          if (offset > 0 && await digest(source, file.source, signal, offset - 1) !== await digest(target, temporary, signal, offset - 1))
+            offset = 0;
+          if (partial && offset === 0) {
+            await target.unlink(temporary);
+            partial = null;
+          }
+          checkpoint.files[id] = {
+            size: file.info.size,
+            mtime: file.info.mtime,
+            target: output,
+            complete: false
+          };
+          saved = checkpoint.files[id];
+          await save();
+          transferred += offset;
+          progress(file.source);
+          if (offset < file.info.size || !partial) {
+            const meter = new Transform({
+              transform(chunk, _encoding, done) {
+                transferred += chunk.length;
+                sessionBytes += chunk.length;
+                progress(file.source);
+                done(null, chunk);
+              }
+            });
+            await pipeline(
+              source.read(file.source, offset),
+              meter,
+              target.write(temporary, offset, Boolean(partial)),
+              { signal }
+            );
+          }
+          assertNotAborted(signal);
+          if (!sameVersion(await source.stat(file.source), file.info))
+            throw new Error(`\u6765\u6E90\u5728\u4F20\u8F93\u4E2D\u53D1\u751F\u53D8\u5316\uFF0C\u672A\u8986\u76D6\u76EE\u6807\uFF1A${file.source}`);
+          if (!sameVersion(await target.stat(output), existing))
+            throw new Error(`\u76EE\u6807\u5728\u4F20\u8F93\u4E2D\u53D1\u751F\u53D8\u5316\uFF0C\u672A\u8986\u76D6\uFF1A${output}`);
+          await target.times(temporary, file.info.mtime);
+          await target.rename(temporary, output, Boolean(existing));
+          saved.complete = true;
+          await save();
+          copied++;
+          bytes += file.info.size;
+          filesDone++;
+          progress(file.source);
+        }
+        return { files: copied, bytes, skipped };
+      },
+      signal
+    );
+  }
+};
+
+// src/ssh/transfer-queue.ts
+import { randomUUID } from "crypto";
+import {
+  closeSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+  writeSync
+} from "fs";
+import { join as join2 } from "path";
+import { z as z2 } from "zod";
+var RECORD_VERSION = 1;
+var MAX_ATTEMPTS = 3;
+var RETRY_DELAYS_MS = [2e3, 5e3];
+var PROGRESS_EMIT_MS = 100;
+var NAMESPACE_PATTERN = /^[A-Za-z0-9_-]{8,128}$/;
+var OWNER_CLAIM_PREFIX = ".owner-";
+var OWNER_CLAIM_SUFFIX = ".lock";
+var liveOwners = /* @__PURE__ */ new Set();
+var JOB_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var JOB_FILE_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.json$/i;
+var OWNER_CLAIM_PATTERN = /^\.owner-(\d+)-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.lock$/i;
+var jobIdSchema = z2.string().regex(JOB_ID_PATTERN, "\u4EFB\u52A1 id \u987B\u4E3A randomUUID");
+var FileTransferRequestSchema = z2.object({
+  id: jobIdSchema,
+  uuid: z2.string().min(1),
+  direction: z2.union([z2.literal("upload"), z2.literal("download")]),
+  sources: z2.array(z2.string().min(1)).min(1),
+  destination: z2.string().min(1),
+  sync: z2.boolean(),
+  checksum: z2.boolean()
+});
+var EnqueueRequestSchema = FileTransferRequestSchema.omit({ id: true });
+var PersistedJobSchema = z2.object({
+  version: z2.literal(1),
+  id: jobIdSchema,
+  enqueuedAt: z2.number(),
+  updatedAt: z2.number(),
+  request: FileTransferRequestSchema,
+  state: z2.union([
+    z2.literal("queued"),
+    z2.literal("running"),
+    z2.literal("conflict"),
+    z2.literal("paused"),
+    z2.literal("completed"),
+    z2.literal("cancelled")
+  ]),
+  error: z2.string().optional(),
+  result: z2.object({ files: z2.number(), bytes: z2.number(), skipped: z2.array(z2.string()) }).optional()
+});
+var QueueAbortError = class extends Error {
+  constructor() {
+    super("\u64CD\u4F5C\u5DF2\u53D6\u6D88");
+    this.name = "QueueAbortError";
+  }
+};
+function validateStoredRecord(raw, filename) {
+  const parsed = PersistedJobSchema.safeParse(raw);
+  if (!parsed.success) {
+    const detail = parsed.error.issues[0]?.message ?? "\u683C\u5F0F\u975E\u6CD5";
+    throw new Error(`\u4F20\u8F93\u8BB0\u5F55\u635F\u574F\uFF08${filename}\uFF09\uFF1A${detail}`);
+  }
+  const rec = parsed.data;
+  if (`${rec.id}.json` !== filename) {
+    throw new Error(`\u4F20\u8F93\u8BB0\u5F55\u635F\u574F\uFF08${filename}\uFF09\uFF1A\u6587\u4EF6\u540D\u4E0E\u8BB0\u5F55 id \u4E0D\u4E00\u81F4`);
+  }
+  if (rec.request.id !== rec.id) {
+    throw new Error(`\u4F20\u8F93\u8BB0\u5F55\u635F\u574F\uFF08${filename}\uFF09\uFF1A\u8BF7\u6C42 id \u4E0E\u8BB0\u5F55 id \u4E0D\u4E00\u81F4`);
+  }
+  return rec;
+}
+function toJobError(err) {
+  let message;
+  let hint;
+  if (err instanceof AutoDLError) {
+    message = err.message;
+    hint = err.hint;
+  } else if (err instanceof Error) {
+    message = err.message;
+  } else {
+    message = String(err);
+  }
+  const combined = hint ? `${message}\uFF08${hint}\uFF09` : message;
+  const clean = combined.replace(/(password|passwd|pwd|token|secret)\s*[:=]\s*\S+/gi, "$1=****").replace(/(-p|--password)\s+\S+/g, "$1 ****").trim();
+  return clean || "\u4F20\u8F93\u5931\u8D25";
+}
+var RETRYABLE_ERRNO = {
+  ECONNRESET: true,
+  ETIMEDOUT: true,
+  EPIPE: true,
+  ECONNREFUSED: true,
+  ENOTFOUND: true,
+  EHOSTUNREACH: true,
+  ENETUNREACH: true,
+  EAI_AGAIN: true
+};
+function isRecoverable(err) {
+  if (err instanceof QueueAbortError) return false;
+  if (err instanceof AutoDLError) {
+    if (err.code === "NETWORK" || err.code === "TIMEOUT") return true;
+    if (err.code === "SSH_FAILED") return hasRecoverableCause(err.cause);
+    return false;
+  }
+  return hasRecoverableCause(err);
+}
+function hasRecoverableCause(err, depth = 0) {
+  if (err === null || err === void 0) return false;
+  if (depth > 5) return false;
+  if (err instanceof AutoDLError) {
+    if (err.code === "NETWORK" || err.code === "TIMEOUT") return true;
+    if (err.code === "SSH_FAILED") return hasRecoverableCause(err.cause, depth + 1);
+    return false;
+  }
+  if (typeof err === "object" && "code" in err && typeof err.code === "string") {
+    if (RETRYABLE_ERRNO[err.code]) return true;
+    if (err instanceof Error && err.cause !== void 0) {
+      return hasRecoverableCause(err.cause, depth + 1);
+    }
+    return false;
+  }
+  if (typeof err === "object" && "level" in err && typeof err.level === "string") {
+    if (/auth/i.test(err.level)) return false;
+  }
+  const msg = err instanceof Error ? err.message : String(err);
+  if (isAuthLike(msg) || isLocalLike(msg)) return false;
+  if (isTransportLike(msg)) return true;
+  if (err instanceof Error && err.cause !== void 0) {
+    return hasRecoverableCause(err.cause, depth + 1);
+  }
+  return false;
+}
+function isAuthLike(msg) {
+  return /auth|password|passwd|credential|permission denied|unauthorized|forbidden|invalid token|expired|登录|密码|权限|认证|未授权|关机|已关机|开机|power|shutdown|offline|not running|无法建立|状态为/i.test(
+    msg
+  );
+}
+function isLocalLike(msg) {
+  return /not found|ENOENT|EACCES|EPERM|EROFS|ENOSPC|EEXIST/i.test(msg);
+}
+function isTransportLike(msg) {
+  return /disconnect|ECONNRESET|ETIMEDOUT|EPIPE|ECONNREFUSED|ENOTFOUND|EHOSTUNREACH|ENETUNREACH|EAI_AGAIN|timed out|timeout|socket|closed|unreachable|temporar|connection lost|broken pipe|reset by peer|通道.{0,8}(中断|断开|重置|超时|关闭)|连接.{0,8}(中断|断开|重置|超时|关闭|丢失)/i.test(
+    msg
+  );
+}
+function isLivePid(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (typeof err === "object" && err !== null && "code" in err) {
+      if (err.code === "EPERM") return true;
+    }
+    return false;
+  }
+}
+function listOwnerClaims(dir) {
+  let files;
+  try {
+    files = readdirSync(dir);
+  } catch (err) {
+    if (typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT") {
+      return [];
+    }
+    throw err;
+  }
+  const claims = [];
+  for (const file of files) {
+    if (file.includes(".tmp.")) continue;
+    if (!file.startsWith(OWNER_CLAIM_PREFIX) || !file.endsWith(OWNER_CLAIM_SUFFIX)) continue;
+    const match = OWNER_CLAIM_PATTERN.exec(file);
+    if (!match?.[1] || !match[2]) {
+      claims.push({ file, pid: Number.NaN, nonce: "", ticket: void 0 });
+      continue;
+    }
+    let ticket;
+    try {
+      const raw = JSON.parse(readFileSync(join2(dir, file), "utf8"));
+      if (typeof raw === "object" && raw !== null && "ticket" in raw && typeof raw.ticket === "number" && Number.isInteger(raw.ticket) && raw.ticket >= 0) {
+        ticket = raw.ticket;
+      }
+    } catch {
+      ticket = void 0;
+    }
+    claims.push({ file, pid: Number(match[1]), nonce: match[2].toLowerCase(), ticket });
+  }
+  return claims;
+}
+function removeOwnClaim(dir, file) {
+  try {
+    rmSync(join2(dir, file), { force: true });
+  } catch {
+  }
+}
+function reapDeadClaims(dir, claims) {
+  for (const claim of claims) {
+    if (Number.isInteger(claim.pid) && !isLivePid(claim.pid)) {
+      removeOwnClaim(dir, claim.file);
+    }
+  }
+}
+function abortableDelay(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    if (signal.aborted) {
+      reject(new QueueAbortError());
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new QueueAbortError());
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function freezeJob(job) {
+  return Object.freeze({
+    request: Object.freeze({ ...job.request }),
+    state: job.state,
+    ...job.progress ? { progress: Object.freeze({ ...job.progress }) } : {},
+    ...job.conflict ? { conflict: Object.freeze({ ...job.conflict }) } : {},
+    ...job.result ? { result: Object.freeze({ ...job.result, skipped: [...job.result.skipped] }) } : {},
+    ...job.error !== void 0 ? { error: job.error } : {}
+  });
+}
+var TransferQueue = class {
+  client;
+  dir;
+  claimFile;
+  jobs = [];
+  listeners = /* @__PURE__ */ new Set();
+  conflicts = /* @__PURE__ */ new Map();
+  active = null;
+  cached = null;
+  pausing = false;
+  disposed = false;
+  constructor(client, namespace) {
+    if (!NAMESPACE_PATTERN.test(namespace)) {
+      throw new Error("\u4F20\u8F93\u961F\u5217\u547D\u540D\u7A7A\u95F4\u975E\u6CD5\uFF1A\u987B\u4E3A 8\u2013128 \u4F4D\u5B57\u6BCD/\u6570\u5B57/_/-");
+    }
+    this.client = client;
+    this.dir = join2(configDir(), "transfers", namespace);
+    for (const job of this.load()) {
+      this.jobs.push(job);
+    }
+  }
+  snapshot() {
+    if (!this.cached) {
+      this.cached = Object.freeze(this.jobs.map(freezeJob));
+    }
+    return this.cached;
+  }
+  subscribe(listener) {
+    this.assertUsable();
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  enqueue(request) {
+    this.assertUsable();
+    const parsed = EnqueueRequestSchema.safeParse(request);
+    if (!parsed.success) {
+      const detail = parsed.error.issues[0]?.message ?? "\u683C\u5F0F\u975E\u6CD5";
+      throw new Error(`\u4F20\u8F93\u8BF7\u6C42\u975E\u6CD5\uFF1A${detail}`);
+    }
+    this.claimOwnership();
+    const id = randomUUID();
+    const job = {
+      request: { ...parsed.data, id },
+      state: "queued",
+      enqueuedAt: Date.now(),
+      cancelRequested: false,
+      lastEmitAt: 0
+    };
+    this.jobs.push(job);
+    try {
+      this.save(job);
+    } catch (err) {
+      const index = this.jobs.indexOf(job);
+      if (index >= 0) this.jobs.splice(index, 1);
+      throw err;
+    }
+    this.emit();
+    this.pump();
+    return id;
+  }
+  resume(id) {
+    this.assertUsable();
+    const job = this.require(id);
+    if (job.state !== "paused" && job.state !== "cancelled") return;
+    try {
+      this.validateStored(job);
+    } catch (err) {
+      job.error = toJobError(err);
+      this.emit();
+      throw err;
+    }
+    this.claimOwnership();
+    const prev = { ...job };
+    job.state = "queued";
+    job.error = void 0;
+    job.result = void 0;
+    job.conflict = void 0;
+    try {
+      this.save(job);
+    } catch (err) {
+      Object.assign(job, prev);
+      this.emit();
+      throw err;
+    }
+    this.emit();
+    this.pump();
+  }
+  cancel(id) {
+    this.assertUsable();
+    const job = this.require(id);
+    if (job.state === "completed" || job.state === "cancelled") return;
+    this.claimOwnership();
+    if (job.state === "running" || job.state === "conflict") {
+      job.cancelRequested = true;
+      job.abort?.abort();
+      this.emit();
+      return;
+    }
+    const prevState = job.state;
+    const prevConflict = job.conflict;
+    job.state = "cancelled";
+    job.conflict = void 0;
+    try {
+      this.save(job);
+    } catch (err) {
+      job.state = prevState;
+      job.conflict = prevConflict;
+      this.emit();
+      throw err;
+    }
+    this.emit();
+  }
+  resolveConflict(id, resolution) {
+    this.assertUsable();
+    const job = this.require(id);
+    if (!resolution || resolution.choice !== "overwrite" && resolution.choice !== "skip" && resolution.choice !== "keep-both") {
+      throw new Error(`\u4EFB\u52A1 ${id}\uFF1A\u51B2\u7A81\u5904\u7406\u9009\u9879\u975E\u6CD5`);
+    }
+    const pending = this.conflicts.get(id);
+    if (!pending || job.state !== "conflict") {
+      throw new Error(`\u4EFB\u52A1 ${id} \u5F53\u524D\u6CA1\u6709\u5F85\u5904\u7406\u7684\u51B2\u7A81`);
+    }
+    this.claimOwnership();
+    pending.resolve({ choice: resolution.choice, applyToAll: resolution.applyToAll === true });
+  }
+  hasPending() {
+    return this.jobs.some(
+      (job) => job.state === "queued" || job.state === "running" || job.state === "conflict"
+    );
+  }
+  async pauseAll() {
+    if (this.disposed) return;
+    this.pausing = true;
+    let firstError;
+    try {
+      firstError = this.parkQueued() ?? firstError;
+      for (const job of this.jobs) {
+        job.abort?.abort();
+      }
+      const active = this.active;
+      if (active) await active.done;
+      firstError = this.parkQueued() ?? firstError;
+      this.emit();
+      if (firstError) throw firstError;
+    } finally {
+      this.pausing = false;
+    }
+  }
+  async dispose() {
+    if (this.disposed) return;
+    try {
+      await this.pauseAll();
+    } finally {
+      this.disposed = true;
+      this.listeners.clear();
+      this.conflicts.clear();
+      this.releaseOwnership();
+    }
+  }
+  /** Park every queued job as paused, persisting each record. */
+  parkQueued() {
+    let firstError;
+    for (const job of this.jobs) {
+      if (job.state === "queued") {
+        job.state = "paused";
+        try {
+          this.save(job);
+        } catch (err) {
+          firstError = firstError ?? err;
+        }
+      }
+    }
+    return firstError;
+  }
+  assertUsable() {
+    if (this.disposed) throw new Error("\u4F20\u8F93\u961F\u5217\u5DF2\u91CA\u653E");
+  }
+  require(id) {
+    if (!JOB_ID_PATTERN.test(id)) throw new Error(`\u672A\u77E5\u4F20\u8F93\u4EFB\u52A1\uFF1A${id}`);
+    const job = this.jobs.find((j) => j.request.id === id);
+    if (!job) throw new Error(`\u672A\u77E5\u4F20\u8F93\u4EFB\u52A1\uFF1A${id}`);
+    return job;
+  }
+  emit() {
+    this.cached = null;
+    for (const listener of [...this.listeners]) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  }
+  /** Invalidate the cached snapshot; notify subscribers at most ~10/s. */
+  noteProgress() {
+    this.cached = null;
+    const now = Date.now();
+    const running = this.jobs.find((j) => j.state === "running");
+    if (running && now - running.lastEmitAt < PROGRESS_EMIT_MS) return;
+    if (running) running.lastEmitAt = now;
+    for (const listener of [...this.listeners]) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  }
+  pump() {
+    if (this.disposed || this.pausing || this.active) return;
+    const next = this.jobs.find((job) => job.state === "queued");
+    if (!next) return;
+    const done = this.runJob(next).then(
+      () => void 0,
+      () => void 0
+    );
+    this.active = { id: next.request.id, done };
+    void done.then(() => {
+      if (this.active?.done === done) this.active = null;
+      if (!this.disposed && !this.pausing) this.pump();
+    });
+  }
+  async runJob(job) {
+    job.state = "running";
+    job.error = void 0;
+    job.result = void 0;
+    job.progress = void 0;
+    job.conflict = void 0;
+    job.cancelRequested = false;
+    const aborter = new AbortController();
+    job.abort = aborter;
+    try {
+      this.save(job);
+    } catch (err) {
+      job.state = "paused";
+      job.error = toJobError(err);
+      job.abort = void 0;
+      this.emit();
+      return;
+    }
+    this.emit();
+    try {
+      this.validateStored(job);
+    } catch (err) {
+      job.state = "paused";
+      job.error = toJobError(err);
+      job.abort = void 0;
+      this.persistBestEffort(job);
+      this.emit();
+      return;
+    }
+    let workspace;
+    try {
+      workspace = new FileWorkspace(this.client, job.request.uuid);
+    } catch (err) {
+      job.state = "paused";
+      job.error = toJobError(err);
+      job.abort = void 0;
+      this.persistBestEffort(job);
+      this.emit();
+      return;
+    }
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+      if (aborter.signal.aborted) break;
+      try {
+        const result = await workspace.transfer(
+          job.request,
+          {
+            onProgress: (progress) => {
+              job.progress = { ...progress };
+              this.noteProgress();
+            },
+            onConflict: (conflict) => {
+              job.state = "conflict";
+              job.conflict = { ...conflict };
+              try {
+                this.save(job);
+              } catch (err) {
+                return Promise.reject(err);
+              }
+              this.emit();
+              const conflictPromise = new Promise((resolve2, reject) => {
+                const onAbort = () => {
+                  reject(new QueueAbortError());
+                };
+                if (aborter.signal.aborted) {
+                  onAbort();
+                } else {
+                  this.conflicts.set(job.request.id, { resolve: resolve2, reject, onAbort });
+                  aborter.signal.addEventListener("abort", onAbort, { once: true });
+                }
+              });
+              return conflictPromise.then((resolution) => {
+                if (!aborter.signal.aborted && job.state === "conflict") {
+                  job.state = "running";
+                  job.conflict = void 0;
+                  this.emit();
+                }
+                return resolution;
+              }).finally(() => {
+                const pending = this.conflicts.get(job.request.id);
+                if (pending) {
+                  aborter.signal.removeEventListener("abort", pending.onAbort);
+                  this.conflicts.delete(job.request.id);
+                }
+              });
+            }
+          },
+          aborter.signal
+        );
+        job.state = "completed";
+        job.result = result;
+        job.conflict = void 0;
+        job.abort = void 0;
+        if (!this.persistBestEffort(job)) {
+          job.error = job.error ?? "\u4F20\u8F93\u5B8C\u6210\uFF0C\u4F46\u961F\u5217\u6301\u4E45\u5316\u5931\u8D25\uFF0C\u91CD\u542F\u540E\u53EF\u80FD\u91CD\u590D\u4F20\u8F93";
+        }
+        this.emit();
+        return;
+      } catch (err) {
+        if (aborter.signal.aborted || err instanceof QueueAbortError) {
+          job.state = job.cancelRequested ? "cancelled" : "paused";
+          job.conflict = void 0;
+          job.abort = void 0;
+          this.persistBestEffort(job);
+          this.emit();
+          return;
+        }
+        if (!isRecoverable(err) || attempt >= MAX_ATTEMPTS) {
+          job.state = "paused";
+          job.error = toJobError(err);
+          job.conflict = void 0;
+          job.abort = void 0;
+          this.persistBestEffort(job);
+          this.emit();
+          return;
+        }
+        try {
+          await abortableDelay(RETRY_DELAYS_MS[attempt - 1] ?? 5e3, aborter.signal);
+        } catch {
+          job.state = job.cancelRequested ? "cancelled" : "paused";
+          job.conflict = void 0;
+          job.abort = void 0;
+          this.persistBestEffort(job);
+          this.emit();
+          return;
+        }
+      }
+    }
+    job.state = job.cancelRequested ? "cancelled" : "paused";
+    job.conflict = void 0;
+    job.abort = void 0;
+    this.persistBestEffort(job);
+    this.emit();
+  }
+  load() {
+    let files;
+    try {
+      files = readdirSync(this.dir);
+    } catch (err) {
+      if (typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT") {
+        return [];
+      }
+      throw new Error(`\u8BFB\u53D6\u4F20\u8F93\u961F\u5217\u5931\u8D25\uFF1A${toJobError(err)}`);
+    }
+    const loaded = [];
+    for (const file of files) {
+      if (!JOB_FILE_PATTERN.test(file)) continue;
+      const full = join2(this.dir, file);
+      let raw;
+      try {
+        raw = JSON.parse(readFileSync(full, "utf8"));
+      } catch (err) {
+        throw new Error(`\u4F20\u8F93\u8BB0\u5F55\u635F\u574F\uFF08${file}\uFF09\uFF1A${toJobError(err)}`);
+      }
+      const rec = validateStoredRecord(raw, file);
+      loaded.push({
+        request: rec.request,
+        // Unfinished work always resumes paused; nothing autostarts.
+        state: rec.state === "completed" || rec.state === "cancelled" || rec.state === "paused" ? rec.state : "paused",
+        result: rec.result,
+        error: rec.error,
+        enqueuedAt: rec.enqueuedAt,
+        cancelRequested: false,
+        lastEmitAt: 0
+      });
+    }
+    loaded.sort((a, b) => a.enqueuedAt - b.enqueuedAt);
+    return loaded;
+  }
+  recordFor(job) {
+    return {
+      version: RECORD_VERSION,
+      id: job.request.id,
+      enqueuedAt: job.enqueuedAt,
+      updatedAt: Date.now(),
+      request: { ...job.request },
+      state: job.state,
+      ...job.error !== void 0 ? { error: job.error } : {},
+      ...job.result ? { result: job.result } : {}
+    };
+  }
+  save(job) {
+    let payload;
+    try {
+      payload = JSON.stringify(this.recordFor(job));
+    } catch (err) {
+      throw new Error(`\u4F20\u8F93\u961F\u5217\u6301\u4E45\u5316\u5931\u8D25\uFF1A${toJobError(err)}`);
+    }
+    const tmp = join2(this.dir, `${job.request.id}.json.tmp.${process.pid}`);
+    const final = join2(this.dir, `${job.request.id}.json`);
+    try {
+      mkdirSync(this.dir, { recursive: true, mode: 448 });
+      writeFileSync(tmp, payload, { mode: 384 });
+      renameSync(tmp, final);
+    } catch (err) {
+      try {
+        rmSync(tmp, { force: true });
+      } catch {
+      }
+      throw new Error(`\u4F20\u8F93\u961F\u5217\u6301\u4E45\u5316\u5931\u8D25\uFF1A${toJobError(err)}`);
+    }
+  }
+  /** Background-transition persist: surface failures on the job, never throw. */
+  persistBestEffort(job) {
+    try {
+      this.save(job);
+      return true;
+    } catch (err) {
+      job.error = toJobError(err);
+      return false;
+    }
+  }
+  /**
+   * Claim exclusive mutation/run ownership for this namespace via fail-fast
+   * bakery tickets over per-process unique claim files. Viewing, snapshotting
+   * and subscribing never call this, so an empty view creates no files.
+   *
+   * Protocol: create `.owner-<pid>-<nonce>.lock` exclusively with ticket 0
+   * (choosing), reap ONLY dead-pid unique names, fail busy if any live or
+   * invalid claim exists, else publish max(ticket)+1 atomically and rescan:
+   * win only when no live choosing claim remains and our (ticket, nonce) is
+   * earliest; otherwise remove ONLY our own unique file and fail busy. A
+   * crashed owner leaves an abandoned unique file its pid no longer resolves
+   * for, so the next writer reaps just that immutable name without ever
+   * deleting a live successor — no central stale rm race, no second reaper,
+   * no external deps. Empty/partial writes parse fail-closed (invalid claim
+   * blocks rather than being reaped). Same-process re-entry by one instance is
+   * a no-op via `claimFile`; a second instance fails fast via liveOwners.
+   */
+  claimOwnership() {
+    if (this.claimFile || this.disposed) return;
+    if (liveOwners.has(this.dir)) {
+      throw new Error(
+        "\u540C\u4E00\u8FDB\u7A0B\u4E2D\u8BE5\u8D26\u53F7\u4F20\u8F93\u961F\u5217\u5DF2\u6709\u5199\u5165\u8005\uFF1A\u540C\u4E00\u65F6\u95F4\u53EA\u5141\u8BB8\u4E00\u4E2A\u961F\u5217\u5B9E\u4F8B\u5199\u5165\uFF0C\u907F\u514D\u5E76\u53D1\u6062\u590D\u540C\u4E00\u4EFB\u52A1\u635F\u574F\u4F20\u8F93\u76EE\u6807"
+      );
+    }
+    const nonce = randomUUID();
+    const file = `${OWNER_CLAIM_PREFIX}${process.pid}-${nonce}${OWNER_CLAIM_SUFFIX}`;
+    const path = join2(this.dir, file);
+    let fd;
+    try {
+      mkdirSync(this.dir, { recursive: true, mode: 448 });
+      fd = openSync(path, "wx", 384);
+      writeSync(fd, JSON.stringify({ pid: process.pid, nonce, ticket: 0, createdAt: Date.now() }));
+      closeSync(fd);
+      fd = void 0;
+    } catch (err) {
+      if (fd !== void 0) {
+        try {
+          closeSync(fd);
+        } catch {
+        }
+      }
+      throw new Error(`\u4F20\u8F93\u961F\u5217\u52A0\u9501\u5931\u8D25\uFF1A${toJobError(err)}`);
+    }
+    reapDeadClaims(this.dir, listOwnerClaims(this.dir));
+    const rivals = listOwnerClaims(this.dir).filter((claim) => claim.file !== file);
+    const liveRival = rivals.find(
+      (claim) => claim.ticket === void 0 || !Number.isInteger(claim.pid) || isLivePid(claim.pid)
+    );
+    if (liveRival) {
+      removeOwnClaim(this.dir, file);
+      throw new Error(
+        Number.isInteger(liveRival.pid) ? `\u4F20\u8F93\u961F\u5217\u6B63\u7531\u8FDB\u7A0B ${liveRival.pid} \u72EC\u5360\u4F7F\u7528\uFF1A\u540C\u4E00\u8D26\u53F7\u961F\u5217\u540C\u4E00\u65F6\u95F4\u53EA\u5141\u8BB8\u4E00\u4E2A\u5199\u5165\u8005\uFF0C\u907F\u514D\u5E76\u53D1\u6062\u590D\u540C\u4E00\u4EFB\u52A1\u635F\u574F\u4F20\u8F93\u76EE\u6807` : "\u4F20\u8F93\u961F\u5217\u6B63\u7531\u53E6\u4E00\u5199\u5165\u8005\u72EC\u5360\u4F7F\u7528\uFF1A\u540C\u4E00\u8D26\u53F7\u961F\u5217\u540C\u4E00\u65F6\u95F4\u53EA\u5141\u8BB8\u4E00\u4E2A\u5199\u5165\u8005\uFF0C\u907F\u514D\u5E76\u53D1\u6062\u590D\u540C\u4E00\u4EFB\u52A1\u635F\u574F\u4F20\u8F93\u76EE\u6807"
+      );
+    }
+    let ticket = 1;
+    for (const claim of rivals) {
+      if (claim.ticket !== void 0 && claim.ticket >= ticket) ticket = claim.ticket + 1;
+    }
+    const ticketPayload = JSON.stringify({
+      pid: process.pid,
+      nonce,
+      ticket,
+      createdAt: Date.now()
+    });
+    const ticketTmp = `${path}.tmp.${process.pid}`;
+    try {
+      writeFileSync(ticketTmp, ticketPayload, { mode: 384 });
+      renameSync(ticketTmp, path);
+    } catch (err) {
+      try {
+        rmSync(ticketTmp, { force: true });
+      } catch {
+      }
+      removeOwnClaim(this.dir, file);
+      throw new Error(`\u4F20\u8F93\u961F\u5217\u52A0\u9501\u5931\u8D25\uFF1A${toJobError(err)}`);
+    }
+    const after = listOwnerClaims(this.dir).filter(
+      (claim) => Number.isInteger(claim.pid) && isLivePid(claim.pid)
+    );
+    if (after.some((claim) => claim.file !== file && claim.ticket === void 0)) {
+      removeOwnClaim(this.dir, file);
+      throw new Error(
+        "\u4F20\u8F93\u961F\u5217\u6B63\u7531\u53E6\u4E00\u5199\u5165\u8005\u72EC\u5360\u4F7F\u7528\uFF1A\u540C\u4E00\u8D26\u53F7\u961F\u5217\u540C\u4E00\u65F6\u95F4\u53EA\u5141\u8BB8\u4E00\u4E2A\u5199\u5165\u8005\uFF0C\u907F\u514D\u5E76\u53D1\u6062\u590D\u540C\u4E00\u4EFB\u52A1\u635F\u574F\u4F20\u8F93\u76EE\u6807"
+      );
+    }
+    const ranked = after.filter((claim) => claim.ticket !== void 0).sort(
+      (a, b) => a.ticket - b.ticket || (a.nonce < b.nonce ? -1 : a.nonce > b.nonce ? 1 : 0)
+    );
+    const earliest = ranked[0];
+    if (!earliest || earliest.file !== file) {
+      removeOwnClaim(this.dir, file);
+      const holder = earliest && Number.isInteger(earliest.pid) ? `\u8FDB\u7A0B ${earliest.pid}` : "\u53E6\u4E00\u5199\u5165\u8005";
+      throw new Error(
+        `\u4F20\u8F93\u961F\u5217\u6B63\u7531${holder}\u72EC\u5360\u4F7F\u7528\uFF1A\u540C\u4E00\u8D26\u53F7\u961F\u5217\u540C\u4E00\u65F6\u95F4\u53EA\u5141\u8BB8\u4E00\u4E2A\u5199\u5165\u8005\uFF0C\u907F\u514D\u5E76\u53D1\u6062\u590D\u540C\u4E00\u4EFB\u52A1\u635F\u574F\u4F20\u8F93\u76EE\u6807`
+      );
+    }
+    this.claimFile = file;
+    liveOwners.add(this.dir);
+  }
+  /** Release our unique claim; deletes ONLY our own immutable filename. */
+  releaseOwnership() {
+    if (!this.claimFile) return;
+    const file = this.claimFile;
+    this.claimFile = void 0;
+    liveOwners.delete(this.dir);
+    removeOwnClaim(this.dir, file);
+  }
+  /** Re-read and validate the disk record before any remote side effect. */
+  validateStored(job) {
+    const full = join2(this.dir, `${job.request.id}.json`);
+    let raw;
+    try {
+      raw = JSON.parse(readFileSync(full, "utf8"));
+    } catch (err) {
+      throw new Error(`\u4F20\u8F93\u8BB0\u5F55\u4E0D\u53EF\u7528\uFF08${job.request.id}\uFF09\uFF1A${toJobError(err)}`);
+    }
+    const rec = validateStoredRecord(raw, `${job.request.id}.json`);
+    const want = job.request;
+    const got = rec.request;
+    if (got.uuid !== want.uuid || got.direction !== want.direction || got.destination !== want.destination || got.sync !== want.sync || got.checksum !== want.checksum || got.sources.length !== want.sources.length || !got.sources.every((s, i) => s === want.sources[i])) {
+      throw new Error(`\u4F20\u8F93\u8BB0\u5F55\u4E0E\u961F\u5217\u4E0D\u4E00\u81F4\uFF08${job.request.id}\uFF09\uFF0C\u5DF2\u505C\u6B62\u6267\u884C`);
+    }
+  }
+};
+
+// src/tui/account.ts
+import { Buffer } from "buffer";
+function identityFromToken(token) {
+  const empty = { uid: null, uuid: null, tenant: null };
+  const parts = token.split(".");
+  if (parts.length < 2) return empty;
+  try {
+    const segment = parts[1];
+    const padded = segment + "=".repeat((4 - segment.length % 4) % 4);
+    const payload = JSON.parse(Buffer.from(padded, "base64url").toString("utf8"));
+    return {
+      uid: typeof payload.uid === "number" ? payload.uid : null,
+      uuid: typeof payload.uuid === "string" ? payload.uuid : null,
+      tenant: typeof payload.tenant === "string" ? payload.tenant : null
+    };
+  } catch {
+    return empty;
+  }
+}
+function tokenOverrideNote(source) {
+  if (source === "env")
+    return "\u6CE8\u610F\uFF1A\u73AF\u5883\u53D8\u91CF AUTODL_TOKEN \u4ECD\u7136\u751F\u6548\uFF0C\u5176\u4F18\u5148\u7EA7\u9AD8\u4E8E\u8FD9\u91CC\u4FDD\u5B58\u7684 Token\u3002";
+  if (source === "flag") return "\u6CE8\u610F\uFF1A\u672C\u6B21\u542F\u52A8\u5E26\u4E86 --token \u53C2\u6570\uFF0C\u5176\u4F18\u5148\u7EA7\u9AD8\u4E8E\u8FD9\u91CC\u4FDD\u5B58\u7684 Token\u3002";
+  return null;
+}
+
+// src/ssh/terminal.ts
+async function connectTerminal(client, uuid, options = {}) {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  if (!stdin.isTTY || !stdout.isTTY) {
+    throw new UsageError("\u81EA\u52A8\u7EC8\u7AEF\u767B\u5F55\u9700\u8981\u771F\u5B9E\u4EA4\u4E92\u7EC8\u7AEF", {
+      hint: "\u5728\u7BA1\u9053\u3001CI \u6216\u5176\u4ED6\u975E TTY \u73AF\u5883\u4E0B\u8BF7\u7528 `autodl exec` \u6267\u884C\u5355\u6761\u547D\u4EE4\u3002"
+    });
+  }
+  assertNotAborted(options.signal);
+  return withSSH(client, uuid, (conn) => runShellSession(conn, options.signal), options);
+}
+function runShellSession(conn, signal) {
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const cleanupPending = () => {
+      signal?.removeEventListener("abort", onPendingAbort);
+      conn.off("close", onConnClose);
+      conn.off("error", onConnError);
+    };
+    const failPending = (err) => {
+      if (settled) return;
+      settled = true;
+      cleanupPending();
+      try {
+        conn.end();
+      } catch {
+      }
+      reject(err);
+    };
+    const onPendingAbort = () => {
+      failPending(new AutoDLError("\u64CD\u4F5C\u5DF2\u53D6\u6D88"));
+    };
+    const onConnClose = () => {
+      failPending(
+        new SSHError("SSH \u8FDE\u63A5\u5DF2\u65AD\u5F00\uFF0C\u8FDC\u7A0B Shell \u672A\u80FD\u542F\u52A8", {
+          hint: "\u5B9E\u4F8B\u53EF\u80FD\u6B63\u5728\u91CD\u542F\uFF0C\u6216\u7F51\u7EDC\u4E2D\u65AD\uFF1B\u7A0D\u540E\u91CD\u8BD5\u3002"
+        })
+      );
+    };
+    const onConnError = (err) => {
+      failPending(new SSHError(`SSH \u8FDE\u63A5\u51FA\u9519\uFF1A${err.message}`, { cause: err }));
+    };
+    if (signal?.aborted) {
+      failPending(new AutoDLError("\u64CD\u4F5C\u5DF2\u53D6\u6D88"));
+      return;
+    }
+    const stdout = process.stdout;
+    const pty = {
+      cols: stdout.columns ?? 80,
+      rows: stdout.rows ?? 24,
+      term: process.env.TERM || "xterm-256color"
+    };
+    signal?.addEventListener("abort", onPendingAbort, { once: true });
+    conn.once("close", onConnClose);
+    conn.once("error", onConnError);
+    try {
+      conn.shell(pty, (err, stream) => {
+        if (settled) {
+          try {
+            stream?.close();
+          } catch {
+          }
+          return;
+        }
+        cleanupPending();
+        if (err || !stream) {
+          settled = true;
+          reject(
+            new SSHError(
+              `\u8FDC\u7A0B Shell \u542F\u52A8\u5931\u8D25\uFF1A${err?.message ?? "\u672A\u77E5\u9519\u8BEF"}`,
+              {
+                hint: "\u8FDE\u63A5\u672C\u8EAB\u5DF2\u5EFA\u7ACB\uFF0C\u4F46\u8FDC\u7AEF\u62D2\u7EDD\u5206\u914D Shell\uFF1B\u7A0D\u540E\u91CD\u8BD5\uFF0C\u6216\u7528 `autodl exec` \u5148\u9A8C\u8BC1\u8FDE\u901A\u6027\u3002",
+                cause: err
+              }
+            )
+          );
+          return;
+        }
+        if (signal?.aborted) {
+          settled = true;
+          try {
+            stream.close();
+          } catch {
+          }
+          reject(new AutoDLError("\u64CD\u4F5C\u5DF2\u53D6\u6D88"));
+          return;
+        }
+        driveSession(conn, stream, signal, resolve2, reject);
+      });
+    } catch (err) {
+      failPending(
+        new SSHError(`\u8FDC\u7A0B Shell \u8BF7\u6C42\u5931\u8D25\uFF1A${err?.message ?? String(err)}`, {
+          cause: err
+        })
+      );
+    }
+  });
+}
+function driveSession(conn, stream, signal, resolve2, reject) {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  const wasRaw = stdin.isRaw;
+  let settled = false;
+  let exitCode = null;
+  let exitSignal = null;
+  let gotExit = false;
+  let connCause;
+  const cleanup = () => {
+    stdin.off("data", onStdinData);
+    stdin.off("end", onStdinGone);
+    stdin.off("close", onStdinGone);
+    stdin.off("error", onStdinError);
+    stdin.pause();
+    stream.off("data", onStdoutData);
+    stream.stderr.off("data", onStdoutData);
+    stream.off("error", onStreamError);
+    stream.off("exit", onStreamExit);
+    stream.off("close", onStreamClose);
+    stream.off("drain", onStreamDrain);
+    stdout.off("drain", onStdoutDrain);
+    stdout.off("error", onStdoutError);
+    stdout.off("close", onStdoutGone);
+    stdout.off("resize", onResize);
+    conn.off("error", onConnError);
+    signal?.removeEventListener("abort", onAbort);
+    if (stdin.isTTY) {
+      try {
+        stdin.setRawMode(wasRaw);
+      } catch {
+      }
+    }
+  };
+  const done = (code) => {
+    if (settled) return;
+    settled = true;
+    cleanup();
+    resolve2(code);
+  };
+  const fail = (err) => {
+    if (settled) return;
+    settled = true;
+    cleanup();
+    try {
+      stream.close();
+    } catch {
+    }
+    reject(err);
+  };
+  const onStdinData = (chunk) => {
+    if (settled) return;
+    let ok = true;
+    try {
+      ok = stream.write(chunk);
+    } catch (err) {
+      fail(err instanceof Error ? err : new Error(String(err)));
+      return;
+    }
+    if (!ok) stdin.pause();
+  };
+  const onStdinGone = () => {
+    fail(
+      new SSHError("\u672C\u5730\u7EC8\u7AEF\u8F93\u5165\u5DF2\u5173\u95ED\uFF0C\u8FDC\u7A0B Shell \u5DF2\u65AD\u5F00", {
+        hint: "\u7EC8\u7AEF\u53EF\u80FD\u88AB\u5173\u95ED\uFF1B\u91CD\u65B0\u6253\u5F00\u7EC8\u7AEF\u540E\u518D\u8BD5\u3002"
+      })
+    );
+  };
+  const onStdinError = (err) => {
+    fail(new SSHError(`\u672C\u5730\u7EC8\u7AEF\u8F93\u5165\u51FA\u9519\uFF1A${err.message}`, { cause: err }));
+  };
+  const onStreamDrain = () => {
+    if (!settled) stdin.resume();
+  };
+  const onStdoutData = (chunk) => {
+    if (settled) return;
+    let ok = true;
+    try {
+      ok = stdout.write(chunk);
+    } catch (err) {
+      fail(err instanceof Error ? err : new Error(String(err)));
+      return;
+    }
+    if (!ok) {
+      stream.pause();
+      stream.stderr.pause();
+    }
+  };
+  const onStdoutDrain = () => {
+    if (settled) return;
+    stream.resume();
+    stream.stderr.resume();
+  };
+  const onStdoutError = (err) => {
+    fail(new SSHError(`\u672C\u5730\u7EC8\u7AEF\u8F93\u51FA\u51FA\u9519\uFF1A${err.message}`, { cause: err }));
+  };
+  const onStdoutGone = () => {
+    fail(
+      new SSHError("\u672C\u5730\u7EC8\u7AEF\u8F93\u51FA\u5DF2\u5173\u95ED\uFF0C\u8FDC\u7A0B Shell \u5DF2\u65AD\u5F00", {
+        hint: "\u7EC8\u7AEF\u53EF\u80FD\u88AB\u5173\u95ED\uFF1B\u91CD\u65B0\u6253\u5F00\u7EC8\u7AEF\u540E\u518D\u8BD5\u3002"
+      })
+    );
+  };
+  const onResize = () => {
+    if (settled) return;
+    try {
+      stream.setWindow(stdout.rows ?? 24, stdout.columns ?? 80, 0, 0);
+    } catch {
+    }
+  };
+  const onAbort = () => {
+    fail(new AutoDLError("\u64CD\u4F5C\u5DF2\u53D6\u6D88"));
+  };
+  const onConnError = (err) => {
+    connCause = err;
+  };
+  const onStreamError = (err) => {
+    fail(new SSHError(`\u8FDC\u7A0B Shell \u51FA\u9519\uFF1A${err.message}`, { cause: err }));
+  };
+  const onStreamExit = (code, signalName) => {
+    gotExit = true;
+    exitCode = typeof code === "number" ? code : null;
+    exitSignal = signalName ?? null;
+  };
+  const onStreamClose = () => {
+    if (gotExit) {
+      done(exitCode ?? (exitSignal ? 128 : 0));
+      return;
+    }
+    fail(
+      new SSHError("\u8FDC\u7A0B\u8FDE\u63A5\u5DF2\u610F\u5916\u65AD\u5F00", {
+        hint: "Shell \u672A\u6B63\u5E38\u9000\u51FA\uFF08\u5B9E\u4F8B\u91CD\u542F\u6216\u7F51\u7EDC\u4E2D\u65AD\u90FD\u53EF\u80FD\uFF09\uFF1B\u91CD\u8FDE\u540E\u68C0\u67E5\u8FDC\u7AEF\u8FDB\u7A0B\u72B6\u6001\u3002",
+        cause: connCause
+      })
+    );
+  };
+  if (signal?.aborted) {
+    try {
+      stream.close();
+    } catch {
+    }
+    reject(new AutoDLError("\u64CD\u4F5C\u5DF2\u53D6\u6D88"));
+    return;
+  }
+  stream.on("data", onStdoutData);
+  stream.stderr.on("data", onStdoutData);
+  stream.on("error", onStreamError);
+  stream.once("exit", onStreamExit);
+  stream.on("close", onStreamClose);
+  stream.on("drain", onStreamDrain);
+  conn.once("error", onConnError);
+  stdout.on("drain", onStdoutDrain);
+  stdout.on("error", onStdoutError);
+  stdout.on("close", onStdoutGone);
+  stdout.on("resize", onResize);
+  stdin.on("error", onStdinError);
+  stdin.on("end", onStdinGone);
+  stdin.on("close", onStdinGone);
+  stdin.on("data", onStdinData);
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    stdin.setRawMode(true);
+  } catch (err) {
+    fail(
+      new SSHError(`\u65E0\u6CD5\u63A5\u7BA1\u672C\u5730\u7EC8\u7AEF\uFF1A${err?.message ?? String(err)}`, {
+        hint: "\u7EC8\u7AEF\u53EF\u80FD\u5728\u8FDE\u63A5\u5EFA\u7ACB\u540E\u88AB\u5173\u95ED\uFF1B\u786E\u8BA4 stdin \u4ECD\u662F\u53EF\u7528 TTY \u540E\u91CD\u8BD5\u3002",
+        cause: err
+      })
+    );
+    return;
+  }
+  stdin.resume();
+}
+
+export {
+  FileWorkspace,
+  TransferQueue,
+  identityFromToken,
+  tokenOverrideNote,
+  connectTerminal
+};
+//# sourceMappingURL=chunk-2E2Y5GFH.js.map