karin-plugin-qgroup-file2openlist 0.0.20 → 0.0.22

package/lib/chunk-AWSGUQPA.js

@@ -0,0 +1,2282 @@
+import {
+  config,
+  time
+} from "./chunk-5WVKHIPK.js";
+import {
+  dir
+} from "./chunk-IZS467MR.js";
+
+// src/apps/groupFiles.ts
+import fs from "fs";
+import path from "path";
+import { Readable, Transform } from "stream";
+import { setTimeout as sleep } from "timers/promises";
+import { pathToFileURL } from "url";
+import { karin, logger } from "node-karin";
+var MAX_FILE_TIMEOUT_SEC = 3e3;
+var MIN_FILE_TIMEOUT_SEC = 10;
+var DEFAULT_PROGRESS_REPORT_EVERY = 10;
+var MAX_TRANSFER_CONCURRENCY = 5;
+var pickFirstString = (...values) => {
+  for (const value of values) {
+    if (typeof value === "string" && value) return value;
+  }
+};
+var pickFirstNumber = (...values) => {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    if (typeof value === "string" && value && Number.isFinite(Number(value))) return Number(value);
+  }
+};
+var csvEscape = (value) => {
+  const str = String(value ?? "");
+  if (/[",\n]/.test(str)) return `"${str.replaceAll('"', '""')}"`;
+  return str;
+};
+var ensureDir = (dirPath) => fs.mkdirSync(dirPath, { recursive: true });
+var readJsonSafe = (filePath) => {
+  try {
+    if (!fs.existsSync(filePath)) return {};
+    const raw = fs.readFileSync(filePath, "utf8");
+    return raw ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
+};
+var writeJsonSafe = (filePath, data) => {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf8");
+};
+var normalizePosixPath = (inputPath, { ensureLeadingSlash = true, stripTrailingSlash = true } = {}) => {
+  let value = String(inputPath ?? "").trim().replaceAll("\\", "/");
+  value = value.replace(/\/+/g, "/");
+  if (!value) value = "/";
+  if (ensureLeadingSlash && !value.startsWith("/")) value = `/${value}`;
+  if (stripTrailingSlash && value.length > 1) value = value.replace(/\/+$/, "");
+  return value;
+};
+var safePathSegment = (input) => {
+  const value = String(input ?? "").replaceAll("\0", "").replaceAll("\\", "_").replaceAll("/", "_").trim();
+  if (!value || value === "." || value === "..") return "unnamed";
+  return value;
+};
+var encodePathForUrl = (posixPath) => {
+  const normalized = normalizePosixPath(posixPath);
+  const segments = normalized.split("/").filter(Boolean).map(encodeURIComponent);
+  return `/${segments.join("/")}`;
+};
+var createThrottleTransform = (bytesPerSec) => {
+  const limit = Math.floor(bytesPerSec || 0);
+  if (!Number.isFinite(limit) || limit <= 0) return null;
+  let nextTime = Date.now();
+  const msPerByte = 1e3 / limit;
+  return new Transform({
+    transform(chunk, _enc, cb) {
+      void (async () => {
+        const size = Buffer.isBuffer(chunk) ? chunk.length : Buffer.byteLength(chunk);
+        const now = Date.now();
+        const start = Math.max(now, nextTime);
+        nextTime = start + size * msPerByte;
+        const waitMs = start - now;
+        if (waitMs > 0) await sleep(waitMs);
+        cb(null, chunk);
+      })().catch((err) => cb(err));
+    }
+  });
+};
+var webdavPropfindListNames = async (params) => {
+  const { davBaseUrl, auth, dirPath, timeoutMs } = params;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const url = `${davBaseUrl}${encodePathForUrl(dirPath)}`;
+    const body = `<?xml version="1.0" encoding="utf-8" ?>
+<d:propfind xmlns:d="DAV:">
+  <d:prop>
+    <d:displayname />
+  </d:prop>
+</d:propfind>`;
+    const res = await fetch(url, {
+      method: "PROPFIND",
+      headers: {
+        Authorization: auth,
+        Depth: "1",
+        "Content-Type": "application/xml; charset=utf-8"
+      },
+      body,
+      redirect: "follow",
+      signal: controller.signal
+    });
+    if (!res.ok) return /* @__PURE__ */ new Set();
+    const text = await res.text();
+    if (!text) return /* @__PURE__ */ new Set();
+    const names = /* @__PURE__ */ new Set();
+    const hrefRegex = /<d:href>([^<]+)<\/d:href>/gi;
+    let match;
+    while (match = hrefRegex.exec(text)) {
+      const href = match[1] ?? "";
+      const decoded = decodeURIComponent(href);
+      const cleaned = decoded.replace(/\/+$/, "");
+      const base = cleaned.split("/").filter(Boolean).pop();
+      if (base) names.add(base);
+    }
+    return names;
+  } catch {
+    return /* @__PURE__ */ new Set();
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var buildUploadFileCandidates = (filePath) => {
+  const normalized = filePath.replaceAll("\\", "/");
+  const candidates = [
+    filePath,
+    normalized
+  ];
+  try {
+    candidates.push(pathToFileURL(filePath).href);
+  } catch {
+  }
+  if (/^[a-zA-Z]:\//.test(normalized)) {
+    candidates.push(`file:///${normalized}`);
+  }
+  return [...new Set(candidates.filter(Boolean))];
+};
+var getGroupSyncStatePath = (groupId) => path.join(dir.DataDir, "group-file-sync-state", `${String(groupId)}.json`);
+var readGroupSyncState = (groupId) => {
+  const raw = readJsonSafe(getGroupSyncStatePath(groupId));
+  if (raw && typeof raw === "object" && raw.version === 1 && raw.files && typeof raw.files === "object") {
+    return {
+      version: 1,
+      groupId: String(raw.groupId ?? groupId),
+      updatedAt: typeof raw.updatedAt === "number" ? raw.updatedAt : Date.now(),
+      lastSyncAt: typeof raw.lastSyncAt === "number" ? raw.lastSyncAt : void 0,
+      files: raw.files
+    };
+  }
+  return {
+    version: 1,
+    groupId: String(groupId),
+    updatedAt: Date.now(),
+    files: {}
+  };
+};
+var writeGroupSyncState = (groupId, state) => {
+  const next = {
+    version: 1,
+    groupId: String(groupId),
+    updatedAt: Date.now(),
+    lastSyncAt: typeof state.lastSyncAt === "number" ? state.lastSyncAt : void 0,
+    files: state.files ?? {}
+  };
+  writeJsonSafe(getGroupSyncStatePath(groupId), next);
+};
+var normalizeSyncMode = (value, fallback) => {
+  const v = String(value ?? "").trim().toLowerCase();
+  if (v === "full" || v === "\u5168\u91CF") return "full";
+  if (v === "incremental" || v === "\u589E\u91CF" || v === "inc") return "incremental";
+  return fallback;
+};
+var getGroupSyncTarget = (cfg, groupId) => {
+  const list = cfg?.groupSyncTargets;
+  if (!Array.isArray(list)) return void 0;
+  return list.find((it) => String(it?.groupId) === String(groupId));
+};
+var getGroupFileListCompat = async (bot, groupId, folderId) => {
+  const groupNum = Number(groupId);
+  if (Number.isFinite(groupNum)) {
+    const onebot = bot?._onebot;
+    if (!folderId && typeof onebot?.getGroupRootFiles === "function") {
+      try {
+        const res = await onebot.getGroupRootFiles(groupNum);
+        return {
+          files: Array.isArray(res?.files) ? res.files : [],
+          folders: Array.isArray(res?.folders) ? res.folders : []
+        };
+      } catch (error) {
+        logger.debug(`[\u7FA4\u6587\u4EF6\u5BFC\u51FA] onebot.getGroupRootFiles \u8C03\u7528\u5931\u8D25\uFF0C\u5C06\u5C1D\u8BD5\u5176\u5B83\u63A5\u53E3: ${formatErrorMessage(error)}`);
+      }
+    }
+    if (folderId && typeof onebot?.getGroupFilesByFolder === "function") {
+      try {
+        const res = await onebot.getGroupFilesByFolder(groupNum, folderId);
+        return {
+          files: Array.isArray(res?.files) ? res.files : [],
+          folders: Array.isArray(res?.folders) ? res.folders : []
+        };
+      } catch (error) {
+        logger.debug(`[\u7FA4\u6587\u4EF6\u5BFC\u51FA] onebot.getGroupFilesByFolder \u8C03\u7528\u5931\u8D25\uFF0C\u5C06\u5C1D\u8BD5\u5176\u5B83\u63A5\u53E3: ${formatErrorMessage(error)}`);
+      }
+    }
+  }
+  if (typeof bot?.getGroupFileList === "function") {
+    try {
+      const res = await bot.getGroupFileList(groupId, folderId);
+      return {
+        files: Array.isArray(res?.files) ? res.files : [],
+        folders: Array.isArray(res?.folders) ? res.folders : []
+      };
+    } catch (error) {
+      logger.debug(`[\u7FA4\u6587\u4EF6\u5BFC\u51FA] getGroupFileList \u8C03\u7528\u5931\u8D25\uFF0C\u5C06\u5C1D\u8BD5 OneBot \u6269\u5C55: ${String(error)}`);
+    }
+  }
+  if (!Number.isFinite(groupNum)) {
+    throw new Error("\u7FA4\u53F7\u65E0\u6CD5\u8F6C\u6362\u4E3A number\uFF0C\u4E14\u5F53\u524D\u9002\u914D\u5668\u4E0D\u652F\u6301 getGroupFileList");
+  }
+  if (!folderId && typeof bot?.getGroupRootFiles === "function") {
+    const res = await bot.getGroupRootFiles(groupNum);
+    return {
+      files: Array.isArray(res?.files) ? res.files : [],
+      folders: Array.isArray(res?.folders) ? res.folders : []
+    };
+  }
+  if (folderId && typeof bot?.getGroupFilesByFolder === "function") {
+    const res = await bot.getGroupFilesByFolder(groupNum, folderId);
+    return {
+      files: Array.isArray(res?.files) ? res.files : [],
+      folders: Array.isArray(res?.folders) ? res.folders : []
+    };
+  }
+  throw new Error("\u5F53\u524D\u9002\u914D\u5668\u4E0D\u652F\u6301\u83B7\u53D6\u7FA4\u6587\u4EF6\u5217\u8868\uFF08getGroupFileList / getGroupRootFiles / getGroupFilesByFolder \u5747\u4E0D\u53EF\u7528\uFF09");
+};
+var resolveGroupFileUrl = async (bot, contact, groupId, file) => {
+  if (!file.fileId) throw new Error("\u7F3A\u5C11 fileId");
+  const reasons = [];
+  if (typeof bot?.getFileUrl === "function") {
+    try {
+      const url = await bot.getFileUrl(contact, file.fileId);
+      if (typeof url === "string" && url) return url;
+      reasons.push("getFileUrl \u8FD4\u56DE\u7A7A\u503C");
+    } catch (error) {
+      reasons.push(`getFileUrl: ${error?.message ?? String(error)}`);
+    }
+  }
+  const groupNum = Number(groupId);
+  if (!Number.isFinite(groupNum)) {
+    throw new Error(reasons[0] ?? "\u7FA4\u53F7\u65E0\u6CD5\u8F6C\u6362\u4E3A number");
+  }
+  const onebot = bot?._onebot;
+  if (typeof onebot?.nc_getFile === "function") {
+    try {
+      const res = await onebot.nc_getFile(file.fileId);
+      if (typeof res?.url === "string" && res.url) return res.url;
+      reasons.push("nc_getFile \u8FD4\u56DE\u7A7A\u503C");
+    } catch (error) {
+      reasons.push(`nc_getFile: ${error?.message ?? String(error)}`);
+    }
+  }
+  if (typeof onebot?.getGroupFileUrl === "function") {
+    try {
+      const res = await onebot.getGroupFileUrl(groupNum, file.fileId, file.busid);
+      if (typeof res?.url === "string" && res.url) return res.url;
+      reasons.push("onebot.getGroupFileUrl \u8FD4\u56DE\u7A7A\u503C");
+    } catch (error) {
+      reasons.push(`onebot.getGroupFileUrl: ${error?.message ?? String(error)}`);
+    }
+    try {
+      const res = await onebot.getGroupFileUrl(groupNum, file.fileId);
+      if (typeof res?.url === "string" && res.url) return res.url;
+    } catch {
+    }
+  }
+  if (typeof bot?.getGroupFileUrl === "function") {
+    try {
+      const res = await bot.getGroupFileUrl(groupNum, file.fileId, file.busid);
+      if (typeof res?.url === "string" && res.url) return res.url;
+      reasons.push("getGroupFileUrl \u8FD4\u56DE\u7A7A\u503C");
+    } catch (error) {
+      reasons.push(`getGroupFileUrl: ${error?.message ?? String(error)}`);
+    }
+    try {
+      const res = await bot.getGroupFileUrl(groupNum, file.fileId);
+      if (typeof res?.url === "string" && res.url) return res.url;
+    } catch (error) {
+      reasons.push(`getGroupFileUrl(no busid): ${error?.message ?? String(error)}`);
+    }
+  }
+  throw new Error(reasons[0] ?? "\u65E0\u6CD5\u83B7\u53D6\u4E0B\u8F7DURL\uFF08\u672A\u627E\u5230\u53EF\u7528\u63A5\u53E3\uFF09");
+};
+var buildOpenListDavBaseUrl = (baseUrl) => {
+  const normalized = String(baseUrl ?? "").trim().replace(/\/+$/, "");
+  if (!normalized) return "";
+  return `${normalized}/dav`;
+};
+var buildOpenListApiBaseUrl = (baseUrl) => {
+  const normalized = String(baseUrl ?? "").trim().replace(/\/+$/, "");
+  if (!normalized) return "";
+  return `${normalized}/api`;
+};
+var isSameOriginUrl = (a, b) => {
+  try {
+    return new URL(a).origin === new URL(b).origin;
+  } catch {
+    return false;
+  }
+};
+var buildOpenListRawUrlAuthHeaders = (params) => {
+  const { rawUrl, baseUrl, token } = params;
+  if (!token) return void 0;
+  if (!isSameOriginUrl(rawUrl, baseUrl)) return void 0;
+  return { Authorization: token };
+};
+var buildOpenListAuthHeader = (username, password) => {
+  const user = String(username ?? "");
+  const pass = String(password ?? "");
+  const token = Buffer.from(`${user}:${pass}`).toString("base64");
+  return `Basic ${token}`;
+};
+var formatErrorMessage = (error) => {
+  if (error instanceof Error) {
+    const base = error.message || String(error);
+    const cause = error.cause;
+    if (cause) {
+      const causeMsg = cause instanceof Error ? cause.message : String(cause);
+      const causeCode = typeof cause === "object" && cause && "code" in cause ? String(cause.code) : "";
+      const extra = [causeCode, causeMsg].filter(Boolean).join(" ");
+      if (extra && extra !== base) return `${base} (${extra})`;
+    }
+    return base;
+  }
+  return String(error);
+};
+var isAbortError = (error) => {
+  return Boolean(error && typeof error === "object" && "name" in error && error.name === "AbortError");
+};
+var isRetryableWebDavError = (error) => {
+  const msg = formatErrorMessage(error);
+  return /ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|ECONNREFUSED|UND_ERR|socket hang up/i.test(msg);
+};
+var fetchTextSafely = async (res) => {
+  try {
+    const text = await res.text();
+    return text.slice(0, 500);
+  } catch {
+    return "";
+  }
+};
+var webdavMkcolOk = (status) => status === 201 || status === 405;
+var openlistApiReadJson = async (res) => {
+  try {
+    return await res.json();
+  } catch {
+    return {};
+  }
+};
+var openlistApiLogin = async (params) => {
+  const { baseUrl, username, password, timeoutMs } = params;
+  const apiBaseUrl = buildOpenListApiBaseUrl(baseUrl);
+  if (!apiBaseUrl) throw new Error(`OpenList API \u5730\u5740\u4E0D\u6B63\u786E: ${baseUrl}`);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), Math.max(1e3, Math.floor(timeoutMs) || 0));
+  try {
+    const url = `${apiBaseUrl}/auth/login`;
+    let res;
+    try {
+      res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          username: String(username ?? ""),
+          password: String(password ?? "")
+        }),
+        redirect: "follow",
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (isAbortError(error)) throw new Error(`OpenList \u767B\u5F55\u8D85\u65F6: ${baseUrl}`);
+      throw new Error(`OpenList \u767B\u5F55\u8BF7\u6C42\u5931\u8D25: ${baseUrl} - ${formatErrorMessage(error)}`);
+    }
+    if (!res.ok) {
+      const body = await fetchTextSafely(res);
+      throw new Error(`OpenList \u767B\u5F55\u5931\u8D25: ${baseUrl} -> ${res.status} ${res.statusText}${body ? ` - ${body}` : ""}`);
+    }
+    const json = await openlistApiReadJson(res);
+    if (typeof json?.code === "number" && json.code !== 200) {
+      const msg = json?.message ? ` - ${json.message}` : "";
+      throw new Error(`OpenList \u767B\u5F55\u5931\u8D25: ${baseUrl} -> code=${json.code}${msg}`);
+    }
+    if (typeof json?.data?.token === "string" && json.data.token) return json.data.token;
+    const hint = json?.message ? ` - ${json.message}` : "";
+    throw new Error(`OpenList \u767B\u5F55\u5931\u8D25: ${baseUrl} \u672A\u83B7\u53D6\u5230 token${hint}`);
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var openlistApiPost = async (params) => {
+  const { baseUrl, token, apiPath, body, timeoutMs } = params;
+  const apiBaseUrl = buildOpenListApiBaseUrl(baseUrl);
+  if (!apiBaseUrl) throw new Error("OpenList API \u5730\u5740\u4E0D\u6B63\u786E\uFF0C\u8BF7\u68C0\u67E5 baseUrl");
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), Math.max(1e3, Math.floor(timeoutMs) || 0));
+  try {
+    const url = `${apiBaseUrl}${apiPath.startsWith("/") ? apiPath : `/${apiPath}`}`;
+    let res;
+    try {
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      const authToken = String(token ?? "").trim();
+      if (authToken) headers.Authorization = authToken;
+      res = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body ?? {}),
+        redirect: "follow",
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (isAbortError(error)) throw new Error(`OpenList API \u8BF7\u6C42\u8D85\u65F6: ${apiPath}`);
+      throw new Error(`OpenList API \u8BF7\u6C42\u5931\u8D25: ${apiPath} - ${formatErrorMessage(error)}`);
+    }
+    if (!res.ok) {
+      const text = await fetchTextSafely(res);
+      throw new Error(`OpenList API \u5931\u8D25: ${apiPath} -> ${res.status} ${res.statusText}${text ? ` - ${text}` : ""}`);
+    }
+    const json = await openlistApiReadJson(res);
+    if (typeof json?.code === "number" && json.code !== 200) {
+      const msg = json?.message ? ` - ${json.message}` : "";
+      throw new Error(`OpenList API \u5931\u8D25: ${apiPath} -> code=${json.code}${msg}`);
+    }
+    return json;
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var openlistApiListEntries = async (params) => {
+  const { baseUrl, token, dirPath, timeoutMs } = params;
+  const normalized = normalizePosixPath(dirPath);
+  const requestedPerPage = typeof params.perPage === "number" ? params.perPage : 1e3;
+  const perPage = Math.max(1, Math.min(5e3, Math.floor(requestedPerPage) || 1e3));
+  const out = [];
+  const maxPages = 2e4;
+  for (let page = 1; page <= maxPages; page++) {
+    const json = await openlistApiPost({
+      baseUrl,
+      token,
+      apiPath: "/fs/list",
+      timeoutMs,
+      body: {
+        path: normalized,
+        password: "",
+        page,
+        per_page: perPage,
+        refresh: false
+      }
+    });
+    const items = Array.isArray(json?.data?.content) ? json.data.content : [];
+    for (const it of items) {
+      const name = String(it?.name ?? "").trim();
+      if (!name) continue;
+      out.push({ name, isDir: Boolean(it?.is_dir) });
+    }
+    const total = typeof json?.data?.total === "number" ? json.data.total : void 0;
+    if (!items.length) break;
+    if (typeof total === "number" && Number.isFinite(total) && out.length >= total) break;
+  }
+  return out;
+};
+var openlistApiGetRawUrl = async (params) => {
+  const { baseUrl, token, filePath, timeoutMs } = params;
+  const normalized = normalizePosixPath(filePath);
+  const json = await openlistApiPost({
+    baseUrl,
+    token,
+    apiPath: "/fs/get",
+    timeoutMs,
+    body: { path: normalized, password: "", refresh: false }
+  });
+  const rawUrl = typeof json?.data?.raw_url === "string" ? json.data.raw_url : "";
+  if (!rawUrl) throw new Error(`OpenList \u83B7\u53D6 raw_url \u5931\u8D25: ${normalized}`);
+  return rawUrl;
+};
+var openlistApiPathExists = async (params) => {
+  const { baseUrl, token, path: filePath, timeoutMs } = params;
+  try {
+    await openlistApiPost({
+      baseUrl,
+      token,
+      apiPath: "/fs/get",
+      timeoutMs,
+      body: { path: normalizePosixPath(filePath), password: "", refresh: false }
+    });
+    return true;
+  } catch (error) {
+    const msg = formatErrorMessage(error);
+    if (/code=404\b/i.test(msg) || /not found/i.test(msg) || /object not found/i.test(msg)) return false;
+    return false;
+  }
+};
+var createOpenListApiDirEnsurer = (baseUrl, token, timeoutMs) => {
+  const ensured = /* @__PURE__ */ new Map();
+  const requestTimeoutMs = Math.max(1e3, Math.floor(timeoutMs) || 0);
+  const ensureDir2 = async (dirPath) => {
+    const normalized = normalizePosixPath(dirPath);
+    if (normalized === "/") return;
+    const segments = normalized.split("/").filter(Boolean);
+    let current = "";
+    for (const segment of segments) {
+      current += `/${segment}`;
+      const existing = ensured.get(current);
+      if (existing) {
+        await existing;
+        continue;
+      }
+      const promise = (async () => {
+        try {
+          await openlistApiPost({
+            baseUrl,
+            token,
+            apiPath: "/fs/mkdir",
+            timeoutMs: requestTimeoutMs,
+            body: { path: current }
+          });
+        } catch (error) {
+          const msg = formatErrorMessage(error);
+          if (/exist/i.test(msg) || /already/i.test(msg) || /重复/i.test(msg)) return;
+          throw error;
+        }
+      })();
+      ensured.set(current, promise);
+      try {
+        await promise;
+      } catch (error) {
+        ensured.delete(current);
+        throw error;
+      }
+    }
+  };
+  return { ensureDir: ensureDir2 };
+};
+var downloadAndUploadByOpenListApiPut = async (params) => {
+  const { sourceUrl, sourceHeaders, targetBaseUrl, targetToken, targetPath, timeoutMs } = params;
+  const apiBaseUrl = buildOpenListApiBaseUrl(targetBaseUrl);
+  if (!apiBaseUrl) throw new Error("\u76EE\u6807 OpenList API \u5730\u5740\u4E0D\u6B63\u786E\uFF0C\u8BF7\u68C0\u67E5\u76EE\u6807 OpenList \u5730\u5740");
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    let downloadRes;
+    try {
+      downloadRes = await fetch(sourceUrl, {
+        headers: sourceHeaders,
+        redirect: "follow",
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (isAbortError(error)) throw new Error("\u6E90\u7AEF\u8BFB\u53D6\u8D85\u65F6");
+      throw new Error(`\u6E90\u7AEF\u8BFB\u53D6\u5931\u8D25: ${formatErrorMessage(error)}`);
+    }
+    if (!downloadRes.ok) {
+      const body = await fetchTextSafely(downloadRes);
+      throw new Error(`\u6E90\u7AEF\u8BFB\u53D6\u5931\u8D25: ${downloadRes.status} ${downloadRes.statusText}${body ? ` - ${body}` : ""}`);
+    }
+    if (!downloadRes.body) throw new Error("\u6E90\u7AEF\u8BFB\u53D6\u5931\u8D25: \u54CD\u5E94\u4F53\u4E3A\u7A7A");
+    const headers = {
+      "File-Path": encodeURIComponent(normalizePosixPath(targetPath))
+    };
+    const authToken = String(targetToken ?? "").trim();
+    if (authToken) headers.Authorization = authToken;
+    const contentType = downloadRes.headers.get("content-type");
+    const contentLength = downloadRes.headers.get("content-length");
+    if (contentType) headers["Content-Type"] = contentType;
+    if (contentLength) headers["Content-Length"] = contentLength;
+    const sourceStream = Readable.fromWeb(downloadRes.body);
+    let putRes;
+    try {
+      putRes = await fetch(`${apiBaseUrl}/fs/put`, {
+        method: "PUT",
+        headers,
+        body: sourceStream,
+        // @ts-expect-error Node fetch streaming body requires duplex
+        duplex: "half",
+        redirect: "follow",
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (isAbortError(error)) throw new Error("\u76EE\u6807\u7AEF\u5199\u5165\u8D85\u65F6\uFF08\u8BF7\u68C0\u67E5\u5BF9\u7AEFOpenList\u8FDE\u63A5/\u6743\u9650\uFF09");
+      throw new Error(`\u76EE\u6807\u7AEF\u5199\u5165\u5931\u8D25: ${formatErrorMessage(error)}`);
+    }
+    if (!putRes.ok) {
+      const body = await fetchTextSafely(putRes);
+      throw new Error(`\u76EE\u6807\u7AEF\u5199\u5165\u5931\u8D25: ${putRes.status} ${putRes.statusText}${body ? ` - ${body}` : ""}`);
+    }
+    const json = await openlistApiReadJson(putRes);
+    if (typeof json?.code === "number" && json.code !== 200) {
+      const msg = json?.message ? ` - ${json.message}` : "";
+      throw new Error(`\u76EE\u6807\u7AEF\u5199\u5165\u5931\u8D25: code=${json.code}${msg}`);
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var retryAsync = async (fn, options) => {
+  const retries = Math.max(0, Math.floor(options.retries) || 0);
+  const delaysMs = options.delaysMs?.length ? options.delaysMs : [300, 900, 2e3];
+  const isRetryable = options.isRetryable ?? (() => true);
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt >= retries || !isRetryable(error)) throw error;
+      const delay = delaysMs[Math.min(attempt, delaysMs.length - 1)];
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+};
+var createWebDavDirEnsurer = (davBaseUrl, auth, timeoutMs) => {
+  const ensured = /* @__PURE__ */ new Map();
+  const requestTimeoutMs = Math.max(1e3, Math.floor(timeoutMs) || 0);
+  const ensureDir2 = async (dirPath) => {
+    const normalized = normalizePosixPath(dirPath);
+    if (normalized === "/") return;
+    const segments = normalized.split("/").filter(Boolean);
+    let current = "";
+    for (const segment of segments) {
+      current += `/${segment}`;
+      const existing = ensured.get(current);
+      if (existing) {
+        await existing;
+        continue;
+      }
+      const promise = (async () => {
+        const url = `${davBaseUrl}${encodePathForUrl(current)}`;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), requestTimeoutMs);
+        try {
+          let res;
+          try {
+            res = await fetch(url, {
+              method: "MKCOL",
+              headers: { Authorization: auth },
+              redirect: "follow",
+              signal: controller.signal
+            });
+          } catch (error) {
+            if (isAbortError(error)) throw new Error(`MKCOL \u8D85\u65F6: ${current}`);
+            throw new Error(`MKCOL \u8BF7\u6C42\u5931\u8D25: ${current} - ${formatErrorMessage(error)}`);
+          }
+          if (webdavMkcolOk(res.status) || res.ok) return;
+          const body = await fetchTextSafely(res);
+          const hint = res.status === 401 ? "\uFF08\u8D26\u53F7/\u5BC6\u7801\u9519\u8BEF\uFF0C\u6216\u672A\u5F00\u542F WebDAV\uFF09" : res.status === 403 ? "\uFF08\u6CA1\u6709 WebDAV \u7BA1\u7406/\u5199\u5165\u6743\u9650\uFF0C\u6216\u76EE\u6807\u76EE\u5F55\u4E0D\u53EF\u5199/\u4E0D\u5728\u7528\u6237\u53EF\u8BBF\u95EE\u8303\u56F4\uFF09" : "";
+          throw new Error(`MKCOL \u5931\u8D25: ${current} -> ${res.status} ${res.statusText}${hint}${body ? ` - ${body}` : ""}`);
+        } finally {
+          clearTimeout(timer);
+        }
+      })();
+      ensured.set(current, promise);
+      try {
+        await promise;
+      } catch (error) {
+        ensured.delete(current);
+        throw error;
+      }
+    }
+  };
+  return { ensureDir: ensureDir2 };
+};
+var downloadAndUploadByWebDav = async (params) => {
+  const { sourceUrl, sourceHeaders, targetUrl, auth, timeoutMs, rateLimitBytesPerSec } = params;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    let downloadRes;
+    try {
+      downloadRes = await fetch(sourceUrl, { headers: sourceHeaders, redirect: "follow", signal: controller.signal });
+    } catch (error) {
+      if (isAbortError(error)) throw new Error("\u4E0B\u8F7D\u8D85\u65F6\uFF08URL\u53EF\u80FD\u5DF2\u5931\u6548\uFF09");
+      throw new Error(`\u4E0B\u8F7D\u8BF7\u6C42\u5931\u8D25: ${formatErrorMessage(error)}`);
+    }
+    if (!downloadRes.ok) {
+      const body = await fetchTextSafely(downloadRes);
+      const hint = downloadRes.status === 403 ? "\uFF08\u53EF\u80FDURL\u5DF2\u8FC7\u671F\uFF0C\u9700\u8981\u91CD\u65B0\u83B7\u53D6\uFF09" : "";
+      throw new Error(`\u4E0B\u8F7D\u5931\u8D25: ${downloadRes.status} ${downloadRes.statusText}${hint}${body ? ` - ${body}` : ""}`);
+    }
+    if (!downloadRes.body) throw new Error("\u4E0B\u8F7D\u5931\u8D25: \u54CD\u5E94\u4F53\u4E3A\u7A7A");
+    const headers = { Authorization: auth };
+    const contentType = downloadRes.headers.get("content-type");
+    const contentLength = downloadRes.headers.get("content-length");
+    if (contentType) headers["Content-Type"] = contentType;
+    if (contentLength) headers["Content-Length"] = contentLength;
+    const sourceStream = Readable.fromWeb(downloadRes.body);
+    const throttle = createThrottleTransform(Math.floor(rateLimitBytesPerSec || 0));
+    const bodyStream = throttle ? sourceStream.pipe(throttle) : sourceStream;
+    let putRes;
+    try {
+      putRes = await fetch(targetUrl, {
+        method: "PUT",
+        headers,
+        body: bodyStream,
+        // @ts-expect-error Node fetch streaming body requires duplex
+        duplex: "half",
+        redirect: "follow",
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (isAbortError(error)) throw new Error("\u4E0A\u4F20\u8D85\u65F6\uFF08\u8BF7\u68C0\u67E5 OpenList \u8FDE\u63A5/\u6743\u9650\uFF09");
+      throw new Error(`\u4E0A\u4F20\u8BF7\u6C42\u5931\u8D25: ${formatErrorMessage(error)}`);
+    }
+    if (!putRes.ok) {
+      const body = await fetchTextSafely(putRes);
+      const hint = putRes.status === 401 ? "\uFF08\u8D26\u53F7/\u5BC6\u7801\u9519\u8BEF\uFF0C\u6216\u672A\u5F00\u542F WebDAV\uFF09" : putRes.status === 403 ? "\uFF08\u6CA1\u6709 WebDAV \u7BA1\u7406/\u5199\u5165\u6743\u9650\uFF0C\u6216\u76EE\u6807\u76EE\u5F55\u4E0D\u53EF\u5199/\u4E0D\u5728\u7528\u6237\u53EF\u8BBF\u95EE\u8303\u56F4\uFF09" : "";
+      throw new Error(`\u4E0A\u4F20\u5931\u8D25: ${putRes.status} ${putRes.statusText}${hint}${body ? ` - ${body}` : ""}`);
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var activeGroupSync = /* @__PURE__ */ new Set();
+var withGroupSyncLock = async (groupId, fn) => {
+  const key = String(groupId);
+  if (activeGroupSync.has(key)) throw new Error("\u8BE5\u7FA4\u540C\u6B65\u4EFB\u52A1\u6B63\u5728\u8FDB\u884C\u4E2D\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5");
+  activeGroupSync.add(key);
+  try {
+    return await fn();
+  } finally {
+    activeGroupSync.delete(key);
+  }
+};
+var buildRemotePathForItem = (item, targetDir, flat) => {
+  const relativeParts = (flat ? [item.name] : item.path.split("/")).filter(Boolean).map(safePathSegment);
+  return normalizePosixPath(path.posix.join(targetDir, ...relativeParts));
+};
+var isSameSyncedFile = (prev, item) => {
+  if (!prev) return false;
+  if (prev.fileId && item.fileId && prev.fileId !== item.fileId) return false;
+  const md5Ok = prev.md5 && item.md5 && prev.md5 === item.md5;
+  const sha1Ok = prev.sha1 && item.sha1 && prev.sha1 === item.sha1;
+  if (md5Ok || sha1Ok) return true;
+  const sizeOk = typeof prev.size === "number" && typeof item.size === "number" && prev.size === item.size;
+  const timeOk = typeof prev.uploadTime === "number" && typeof item.uploadTime === "number" && prev.uploadTime === item.uploadTime;
+  if (sizeOk && timeOk) return true;
+  if (timeOk && prev.fileId && item.fileId && prev.fileId === item.fileId) return true;
+  if (sizeOk && prev.fileId && item.fileId && prev.fileId === item.fileId) return true;
+  return false;
+};
+var runWithConcurrency = async (items, concurrency, fn) => {
+  const limit = Math.max(1, Math.floor(concurrency) || 1);
+  const executing = /* @__PURE__ */ new Set();
+  for (let index = 0; index < items.length; index++) {
+    const item = items[index];
+    const task = (async () => fn(item, index))();
+    executing.add(task);
+    task.finally(() => executing.delete(task));
+    if (executing.size >= limit) {
+      await Promise.race(executing);
+    }
+  }
+  await Promise.all(executing);
+};
+var runWithAdaptiveConcurrency = async (items, options) => {
+  const max = Math.max(1, Math.floor(options.max) || 1);
+  let current = Math.min(max, Math.max(1, Math.floor(options.initial) || 1));
+  const onAdjust = options.onAdjust;
+  const results = [];
+  const pushResult = (ok, ms, reason) => {
+    results.push({ ok, ms, reason });
+    if (results.length > 20) results.shift();
+    if (results.length < 10) return;
+    if (results.length % 5 !== 0) return;
+    const failCount = results.filter((r) => !r.ok).length;
+    const failRate = failCount / results.length;
+    const avgMs = results.reduce((acc, r) => acc + r.ms, 0) / results.length;
+    const hasTimeout = results.some((r) => (r.reason || "").includes("\u8D85\u65F6"));
+    if (hasTimeout || failRate >= 0.2) {
+      if (current > 1) {
+        current -= 1;
+        onAdjust?.(current, hasTimeout ? "timeout" : `failRate=${failRate.toFixed(2)}`);
+      }
+      return;
+    }
+    if (failCount === 0 && current < max) {
+      if (avgMs < 6e4 || results.length === 20) {
+        current += 1;
+        onAdjust?.(current, "stable");
+      }
+    }
+  };
+  let nextIndex = 0;
+  const executing = /* @__PURE__ */ new Set();
+  const launch = (index) => {
+    const item = items[index];
+    const start = Date.now();
+    const task = (async () => {
+      try {
+        await options.fn(item, index);
+        pushResult(true, Date.now() - start);
+      } catch (error) {
+        const msg = formatErrorMessage(error);
+        pushResult(false, Date.now() - start, msg);
+        throw error;
+      }
+    })();
+    executing.add(task);
+    task.finally(() => executing.delete(task));
+    return task;
+  };
+  while (nextIndex < items.length || executing.size) {
+    while (nextIndex < items.length && executing.size < current) {
+      launch(nextIndex);
+      nextIndex++;
+    }
+    if (executing.size) await Promise.race(executing);
+  }
+};
+var collectAllGroupFiles = async (bot, groupId, startFolderId) => {
+  const files = [];
+  const visitedFolders = /* @__PURE__ */ new Set();
+  const walk = async (folderId, prefix) => {
+    if (folderId) {
+      if (visitedFolders.has(folderId)) return;
+      visitedFolders.add(folderId);
+    }
+    const { files: rawFiles, folders: rawFolders } = await getGroupFileListCompat(bot, groupId, folderId);
+    for (const raw of rawFiles) {
+      const fileId = pickFirstString(raw?.fid, raw?.file_id, raw?.fileId, raw?.id);
+      const name = pickFirstString(raw?.name, raw?.file_name, raw?.fileName) ?? (fileId ? `file-${fileId}` : "unknown-file");
+      const filePath = prefix ? `${prefix}/${name}` : name;
+      files.push({
+        path: filePath,
+        fileId: fileId ?? "",
+        name,
+        size: pickFirstNumber(raw?.size, raw?.file_size, raw?.fileSize),
+        uploadTime: pickFirstNumber(raw?.uploadTime, raw?.upload_time),
+        uploaderId: pickFirstString(raw?.uploadId, raw?.uploader, raw?.uploader_id),
+        uploaderName: pickFirstString(raw?.uploadName, raw?.uploader_name),
+        md5: pickFirstString(raw?.md5),
+        sha1: pickFirstString(raw?.sha1),
+        sha3: pickFirstString(raw?.sha3),
+        busid: pickFirstNumber(raw?.busid, raw?.busId)
+      });
+    }
+    for (const raw of rawFolders) {
+      const folderId2 = pickFirstString(raw?.id, raw?.folder_id, raw?.folderId);
+      if (!folderId2) continue;
+      const folderName = pickFirstString(raw?.name, raw?.folder_name, raw?.folderName) ?? folderId2;
+      const nextPrefix = prefix ? `${prefix}/${folderName}` : folderName;
+      await walk(folderId2, nextPrefix);
+    }
+  };
+  await walk(startFolderId, "");
+  return files;
+};
+var normalizeGroupFileRelativePath = (input) => {
+  return String(input ?? "").replaceAll("\0", "").replaceAll("\\", "/").trim().replace(/^\/+/, "").replace(/\/+$/, "");
+};
+var locateGroupFileById = async (bot, groupId, fileId, options) => {
+  const timeoutMs = Math.max(1e3, Math.floor(options?.timeoutMs ?? 12e3));
+  const maxFolders = Math.max(1, Math.floor(options?.maxFolders ?? 2e3));
+  const expectedName = String(options?.expectedName ?? "").trim();
+  const expectedSize = typeof options?.expectedSize === "number" && Number.isFinite(options.expectedSize) ? Math.max(0, Math.floor(options.expectedSize)) : void 0;
+  const start = Date.now();
+  const visited = /* @__PURE__ */ new Set();
+  const queued = /* @__PURE__ */ new Set();
+  const stack = [{ folderId: void 0, prefix: "" }];
+  let scanned = 0;
+  let bestCandidate;
+  while (stack.length) {
+    if (Date.now() - start > timeoutMs) return bestCandidate;
+    if (scanned >= maxFolders) return bestCandidate;
+    const current = stack.pop();
+    const folderId = current.folderId;
+    const prefix = current.prefix;
+    if (folderId) {
+      if (visited.has(folderId)) continue;
+      visited.add(folderId);
+    }
+    scanned++;
+    const { files: rawFiles, folders: rawFolders } = await getGroupFileListCompat(bot, groupId, folderId);
+    for (const raw of rawFiles) {
+      const id = pickFirstString(raw?.fid, raw?.file_id, raw?.fileId, raw?.id);
+      const uploadTime = pickFirstNumber(raw?.uploadTime, raw?.upload_time);
+      const size = pickFirstNumber(raw?.size, raw?.file_size, raw?.fileSize);
+      const busid = pickFirstNumber(raw?.busid, raw?.busId);
+      if (!id || String(id) !== String(fileId)) continue;
+      const name = pickFirstString(raw?.name, raw?.file_name, raw?.fileName) ?? (id ? `file-${id}` : "unknown-file");
+      const filePath = prefix ? `${prefix}/${name}` : name;
+      return {
+        path: filePath,
+        name,
+        busid
+      };
+    }
+    if (expectedName) {
+      for (const raw of rawFiles) {
+        const id = pickFirstString(raw?.fid, raw?.file_id, raw?.fileId, raw?.id);
+        if (!id) continue;
+        const name = pickFirstString(raw?.name, raw?.file_name, raw?.fileName) ?? (id ? `file-${id}` : "unknown-file");
+        if (String(name).trim() !== expectedName) continue;
+        const size = pickFirstNumber(raw?.size, raw?.file_size, raw?.fileSize);
+        if (typeof expectedSize === "number") {
+          if (typeof size !== "number" || !Number.isFinite(size) || Math.floor(size) !== expectedSize) continue;
+        }
+        const uploadTime = pickFirstNumber(raw?.uploadTime, raw?.upload_time);
+        const busid = pickFirstNumber(raw?.busid, raw?.busId);
+        const filePath = prefix ? `${prefix}/${name}` : name;
+        if (!bestCandidate) {
+          bestCandidate = { path: filePath, name, busid, uploadTime };
+          continue;
+        }
+        const bestTime = typeof bestCandidate.uploadTime === "number" ? bestCandidate.uploadTime : -1;
+        const currentTime = typeof uploadTime === "number" ? uploadTime : -1;
+        if (currentTime > bestTime) bestCandidate = { path: filePath, name, busid, uploadTime };
+      }
+    }
+    for (const raw of rawFolders) {
+      const id = pickFirstString(raw?.id, raw?.folder_id, raw?.folderId);
+      if (!id) continue;
+      if (visited.has(id) || queued.has(id)) continue;
+      queued.add(id);
+      const folderName = pickFirstString(raw?.name, raw?.folder_name, raw?.folderName) ?? id;
+      const nextPrefix = prefix ? `${prefix}/${folderName}` : folderName;
+      stack.push({ folderId: id, prefix: nextPrefix });
+    }
+  }
+  return bestCandidate;
+};
+var locateGroupFileByIdWithRetry = async (bot, groupId, fileId, options) => {
+  const retries = Math.max(0, Math.floor(options?.retries ?? 2));
+  const delayMs = Math.max(0, Math.floor(options?.delayMs ?? 800));
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const found = await locateGroupFileById(bot, groupId, fileId, options);
+      if (found?.path) return found;
+    } catch (error) {
+      lastError = error;
+    }
+    if (attempt < retries && delayMs > 0) await sleep(delayMs);
+  }
+  if (lastError) throw lastError;
+};
+var writeExportFile = (format, outPath, payload, list) => {
+  ensureDir(path.dirname(outPath));
+  if (format === "json") {
+    fs.writeFileSync(outPath, JSON.stringify(payload, null, 2), "utf8");
+    return;
+  }
+  const header = ["path", "name", "fileId", "size", "uploadTime", "uploaderId", "uploaderName", "md5", "sha1", "sha3", "url", "busid"];
+  const rows = [header.join(",")];
+  for (const item of list) {
+    rows.push([
+      csvEscape(item.path),
+      csvEscape(item.name),
+      csvEscape(item.fileId),
+      csvEscape(item.size ?? ""),
+      csvEscape(item.uploadTime ?? ""),
+      csvEscape(item.uploaderId ?? ""),
+      csvEscape(item.uploaderName ?? ""),
+      csvEscape(item.md5 ?? ""),
+      csvEscape(item.sha1 ?? ""),
+      csvEscape(item.sha3 ?? ""),
+      csvEscape(item.url ?? ""),
+      csvEscape(item.busid ?? "")
+    ].join(","));
+  }
+  fs.writeFileSync(outPath, rows.join("\n"), "utf8");
+};
+var parseArgs = (text) => {
+  const raw = text.trim();
+  const tokens = raw ? raw.split(/\s+/).filter(Boolean) : [];
+  const format = /(^|\s)(--csv|csv)(\s|$)/i.test(raw) ? "csv" : "json";
+  const withUrl = !/(^|\s)(--no-url|--nourl|no-url|nourl)(\s|$)/i.test(raw);
+  const urlOnly = /(^|\s)(--url-only|--urlonly|url-only|urlonly)(\s|$)/i.test(raw);
+  const sendFile = /(^|\s)(--send-file|--sendfile|send-file|sendfile)(\s|$)/i.test(raw);
+  let groupId;
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    const nextToken = tokens[i + 1];
+    if (/^--(group|gid|groupid)$/i.test(token) && nextToken && /^\d+$/.test(nextToken)) {
+      groupId = nextToken;
+      break;
+    }
+    const assignMatch = token.match(/^(group|gid|groupid)=(\d+)$/i);
+    if (assignMatch) {
+      groupId = assignMatch[2];
+      break;
+    }
+  }
+  if (!groupId) {
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i];
+      const prevToken = tokens[i - 1];
+      if (!/^\d+$/.test(token)) continue;
+      if (prevToken && /^--(folder|max|concurrency|group|gid|groupid)$/i.test(prevToken)) continue;
+      groupId = token;
+      break;
+    }
+  }
+  const folderMatch = raw.match(/--folder\s+(\S+)/i) ?? raw.match(/(^|\s)folder=(\S+)/i);
+  const folderId = folderMatch ? folderMatch[folderMatch.length - 1] : void 0;
+  const maxMatch = raw.match(/--max\s+(\d+)/i) ?? raw.match(/(^|\s)max=(\d+)/i);
+  const maxFiles = maxMatch ? Number(maxMatch[maxMatch.length - 1]) : void 0;
+  const concurrencyMatch = raw.match(/--concurrency\s+(\d+)/i) ?? raw.match(/(^|\s)concurrency=(\d+)/i);
+  const concurrency = concurrencyMatch ? Number(concurrencyMatch[concurrencyMatch.length - 1]) : void 0;
+  const concurrencySpecified = Boolean(concurrencyMatch);
+  const help = /(^|\s)(--help|-h|help|\?)(\s|$)/i.test(raw);
+  return { groupId, format, withUrl, urlOnly, sendFile, folderId, maxFiles, concurrency, concurrencySpecified, help };
+};
+var parseSyncArgs = (text) => {
+  const raw = text.trim();
+  const base = parseArgs(text);
+  const toMatch = raw.match(/--to\s+(\S+)/i) ?? raw.match(/(^|\s)to=(\S+)/i);
+  const to = toMatch ? toMatch[toMatch.length - 1] : void 0;
+  const toSpecified = Boolean(toMatch);
+  const flatFlag = /(^|\s)(--flat|flat)(\s|$)/i.test(raw);
+  const keepFlag = /(^|\s)(--keep|--no-flat|keep|no-flat)(\s|$)/i.test(raw);
+  const flatSpecified = flatFlag || keepFlag;
+  const flat = flatFlag ? true : keepFlag ? false : void 0;
+  const help = /(^|\s)(--help|-h|help|\?)(\s|$)/i.test(raw);
+  const concurrency = base.concurrency;
+  const concurrencySpecified = base.concurrencySpecified;
+  const timeoutMatch = raw.match(/--timeout\s+(\d+)/i) ?? raw.match(/(^|\s)timeout=(\d+)/i);
+  const timeoutSec = timeoutMatch ? Number(timeoutMatch[timeoutMatch.length - 1]) : void 0;
+  const timeoutSpecified = Boolean(timeoutMatch);
+  const modeFull = /(^|\s)(--full|full)(\s|$)/i.test(raw);
+  const modeInc = /(^|\s)(--inc|--incremental|inc|incremental)(\s|$)/i.test(raw);
+  const mode = modeFull ? "full" : modeInc ? "incremental" : void 0;
+  return {
+    groupId: base.groupId,
+    folderId: base.folderId,
+    maxFiles: base.maxFiles,
+    concurrency,
+    concurrencySpecified,
+    flat,
+    flatSpecified,
+    to,
+    toSpecified,
+    timeoutSec,
+    timeoutSpecified,
+    mode,
+    help
+  };
+};
+var helpText = [
+  "\u7FA4\u6587\u4EF6\u5BFC\u51FA\u7528\u6CD5\uFF1A",
+  "- \u8BF7\u79C1\u804A\u53D1\u9001\uFF1A#\u5BFC\u51FA\u7FA4\u6587\u4EF6 <\u7FA4\u53F7> [\u53C2\u6570]",
+  "- \u793A\u4F8B\uFF1A#\u5BFC\u51FA\u7FA4\u6587\u4EF6 123456",
+  "- #\u5BFC\u51FA\u7FA4\u6587\u4EF6 123456 --no-url\uFF1A\u53EA\u5BFC\u51FA\u5217\u8868\uFF0C\u4E0D\u89E3\u6790URL",
+  "- #\u5BFC\u51FA\u7FA4\u6587\u4EF6 123456 --url-only\uFF1A\u4EC5\u8F93\u51FAURL\uFF08\u66F4\u65B9\u4FBF\u590D\u5236\uFF09",
+  "- #\u5BFC\u51FA\u7FA4\u6587\u4EF6 123456 --csv\uFF1A\u5BFC\u51FA\u4E3ACSV\uFF08\u9ED8\u8BA4JSON\uFF09",
+  "- #\u5BFC\u51FA\u7FA4\u6587\u4EF6 123456 --folder <id>\uFF1A\u4ECE\u6307\u5B9A\u6587\u4EF6\u5939\u5F00\u59CB\u5BFC\u51FA",
+  "- #\u5BFC\u51FA\u7FA4\u6587\u4EF6 123456 --max <n>\uFF1A\u6700\u591A\u5BFC\u51FAn\u6761\u6587\u4EF6\u8BB0\u5F55",
+  "- #\u5BFC\u51FA\u7FA4\u6587\u4EF6 123456 --concurrency <n>\uFF1A\u89E3\u6790URL\u5E76\u53D1\u6570\uFF08\u9ED8\u8BA43\uFF09",
+  "- #\u5BFC\u51FA\u7FA4\u6587\u4EF6 123456 --send-file\uFF1A\u5C1D\u8BD5\u53D1\u9001\u5BFC\u51FA\u6587\u4EF6\uFF08\u4F9D\u8D56\u534F\u8BAE\u7AEF\u652F\u6301\uFF09",
+  "\u63D0\u793A\uFF1A\u4E0B\u8F7DURL\u901A\u5E38\u6709\u65F6\u6548\uFF0C\u8FC7\u671F\u540E\u9700\u91CD\u65B0\u5BFC\u51FA\u3002"
+].join("\n");
+var exportGroupFiles = karin.command(/^#?(导出群文件|群文件导出)(.*)$/i, async (e) => {
+  if (!e.isPrivate) return false;
+  const argsText = e.msg.replace(/^#?(导出群文件|群文件导出)/i, "");
+  const { groupId, format, withUrl, urlOnly, sendFile, folderId, maxFiles, concurrency, help } = parseArgs(argsText);
+  if (help) {
+    await e.reply(helpText);
+    return true;
+  }
+  if (!groupId) {
+    await e.reply(`\u7F3A\u5C11\u7FA4\u53F7\u53C2\u6570
+
+${helpText}`);
+    return true;
+  }
+  const groupContact = karin.contactGroup(groupId);
+  await e.reply(`\u5F00\u59CB\u5BFC\u51FA\u7FA4\u6587\u4EF6\u5217\u8868\uFF0C\u8BF7\u7A0D\u5019...
+- \u7FA4\u53F7\uFF1A${groupId}
+- \u683C\u5F0F\uFF1A${format}
+- \u5305\u542BURL\uFF1A${withUrl ? "\u662F" : "\u5426"}`);
+  const errors = [];
+  let list = [];
+  try {
+    list = await collectAllGroupFiles(e.bot, groupId, folderId);
+  } catch (error) {
+    logger.error(error);
+    await e.reply(`\u5BFC\u51FA\u5931\u8D25\uFF1A${formatErrorMessage(error)}`);
+    return true;
+  }
+  const limitedList = typeof maxFiles === "number" && Number.isFinite(maxFiles) && maxFiles > 0 ? list.slice(0, Math.floor(maxFiles)) : list;
+  if (withUrl) {
+    const urlConcurrency = typeof concurrency === "number" && Number.isFinite(concurrency) && concurrency > 0 ? concurrency : 3;
+    await runWithConcurrency(limitedList, urlConcurrency, async (item) => {
+      try {
+        item.url = await resolveGroupFileUrl(e.bot, groupContact, groupId, item);
+      } catch (error) {
+        errors.push({
+          fileId: item.fileId,
+          path: item.path,
+          message: formatErrorMessage(error)
+        });
+      }
+    });
+  }
+  const exportDir = path.join(dir.karinPath, "data", "group-files-export");
+  const exportName = `group-files-${groupId}-${time("YYYYMMDD-HHmmss")}.${format}`;
+  const exportPath = path.join(exportDir, exportName);
+  const payload = {
+    type: "group-files-export",
+    plugin: { name: dir.name, version: dir.version },
+    groupId,
+    folderId: folderId ?? null,
+    exportedAt: time(),
+    withUrl,
+    fileCount: limitedList.length,
+    errors,
+    files: limitedList
+  };
+  try {
+    writeExportFile(format, exportPath, payload, limitedList);
+  } catch (error) {
+    logger.error(error);
+    await e.reply(`\u5199\u5165\u5BFC\u51FA\u6587\u4EF6\u5931\u8D25\uFF1A${formatErrorMessage(error)}`);
+    return true;
+  }
+  const urlOk = withUrl ? limitedList.filter((v) => typeof v.url === "string" && v.url).length : 0;
+  const urlFail = withUrl ? limitedList.length - urlOk : 0;
+  const summary = [
+    `\u5BFC\u51FA\u5B8C\u6210\uFF1A${limitedList.length} \u4E2A\u6587\u4EF6`,
+    withUrl ? `URL\uFF1A\u6210\u529F ${urlOk} / \u5931\u8D25 ${urlFail}` : null,
+    `\u5BFC\u51FA\u6587\u4EF6\uFF1A${exportName}`,
+    `\u5BFC\u51FA\u6587\u4EF6\u5DF2\u4FDD\u5B58\u81F3\uFF1A${exportPath}`
+  ].filter(Boolean).join("\n");
+  await e.reply(summary);
+  const textMax = 200;
+  const preview = limitedList.slice(0, textMax);
+  const errorByFileId = /* @__PURE__ */ new Map();
+  for (const err of errors) {
+    if (err.fileId && err.message && !errorByFileId.has(err.fileId)) errorByFileId.set(err.fileId, err.message);
+  }
+  const compactError = (message) => message.replace(/\s+/g, " ").slice(0, 120);
+  const lines = preview.map((item, index) => {
+    if (!withUrl) return `${index + 1}. ${item.path}	${item.fileId}`;
+    if (urlOnly) return item.url ? item.url : `(\u83B7\u53D6URL\u5931\u8D25) ${item.path} (${item.fileId})`;
+    if (item.url) return `${index + 1}. ${item.path}
+${item.url}`;
+    const errMsg = errorByFileId.get(item.fileId);
+    return `${index + 1}. ${item.path}
+(\u83B7\u53D6URL\u5931\u8D25) fileId=${item.fileId}${errMsg ? `
+\u539F\u56E0\uFF1A${compactError(errMsg)}` : ""}`;
+  });
+  const chunks = [];
+  const maxChunkLen = 1500;
+  let buf = "";
+  for (const line of lines) {
+    const next = buf ? `${buf}
+
+${line}` : line;
+    if (next.length > maxChunkLen) {
+      if (buf) chunks.push(buf);
+      buf = line;
+    } else {
+      buf = next;
+    }
+  }
+  if (buf) chunks.push(buf);
+  const maxMessages = 10;
+  for (const chunk of chunks.slice(0, maxMessages)) {
+    await e.reply(chunk);
+  }
+  if (limitedList.length > preview.length) {
+    await e.reply(`\uFF08\u5DF2\u7701\u7565 ${limitedList.length - preview.length} \u6761\uFF0C\u53EF\u4F7F\u7528 --max \u8C03\u6574\uFF09`);
+  } else if (chunks.length > maxMessages) {
+    await e.reply(`\uFF08\u6D88\u606F\u8FC7\u957F\uFF0C\u5DF2\u7701\u7565\u540E\u7EED\u5185\u5BB9\uFF1B\u53EF\u4F7F\u7528 --max \u51CF\u5C11\u6761\u6570\uFF09`);
+  }
+  if (sendFile && typeof e.bot?.uploadFile === "function") {
+    const candidates = buildUploadFileCandidates(exportPath);
+    for (const fileParam of candidates) {
+      try {
+        await e.bot.uploadFile(e.contact, fileParam, exportName);
+        break;
+      } catch {
+      }
+    }
+  }
+  return true;
+}, {
+  priority: 9999,
+  log: true,
+  name: "\u5BFC\u51FA\u7FA4\u6587\u4EF6",
+  permission: "all"
+});
+var syncHelpText = [
+  "\u7FA4\u6587\u4EF6\u540C\u6B65\u5230 OpenList \u7528\u6CD5\uFF1A",
+  "- \u79C1\u804A\uFF1A#\u540C\u6B65\u7FA4\u6587\u4EF6 <\u7FA4\u53F7> [\u53C2\u6570]",
+  "- \u6CE8\u610F\uFF1A\u9ED8\u8BA4\u4EC5\u79C1\u804A\u54CD\u5E94\uFF08\u7FA4\u804A\u4E0D\u4F1A\u89E6\u53D1\u8BE5\u6307\u4EE4\uFF09",
+  "- \u793A\u4F8B\uFF1A#\u540C\u6B65\u7FA4\u6587\u4EF6 123456",
+  "- #\u540C\u6B65\u7FA4\u6587\u4EF6 123456 --to /\u76EE\u6807\u76EE\u5F55\uFF1A\u4E0A\u4F20\u5230\u6307\u5B9A\u76EE\u5F55\uFF08\u9ED8\u8BA4\u4F7F\u7528\u914D\u7F6E openlistTargetDir\uFF09",
+  "- #\u540C\u6B65\u7FA4\u6587\u4EF6 123456 --flat\uFF1A\u4E0D\u4FDD\u7559\u7FA4\u6587\u4EF6\u5939\u7ED3\u6784\uFF0C\u5168\u90E8\u5E73\u94FA\u5230\u76EE\u6807\u76EE\u5F55",
+  "- #\u540C\u6B65\u7FA4\u6587\u4EF6 123456 --keep\uFF1A\u5F3A\u5236\u4FDD\u7559\u76EE\u5F55\u7ED3\u6784\uFF08\u8986\u76D6\u7FA4\u914D\u7F6E flat\uFF09",
+  "- #\u540C\u6B65\u7FA4\u6587\u4EF6 123456 --folder <id>\uFF1A\u4ECE\u6307\u5B9A\u6587\u4EF6\u5939\u5F00\u59CB",
+  "- #\u540C\u6B65\u7FA4\u6587\u4EF6 123456 --max <n>\uFF1A\u6700\u591A\u5904\u7406 n \u4E2A\u6587\u4EF6",
+  "- #\u540C\u6B65\u7FA4\u6587\u4EF6 123456 --concurrency <n>\uFF1A\u5E76\u53D1\u6570\uFF08\u4F1A\u8986\u76D6\u7FA4\u914D\u7F6E\u7684\u5E76\u53D1\uFF09",
+  "- #\u540C\u6B65\u7FA4\u6587\u4EF6 123456 --timeout <sec>\uFF1A\u5355\u6587\u4EF6\u8D85\u65F6\u79D2\u6570\uFF08\u4EC5\u5F71\u54CD\u5355\u4E2A\u6587\u4EF6\uFF09",
+  "- #\u540C\u6B65\u7FA4\u6587\u4EF6 123456 --full/--inc\uFF1A\u8986\u76D6\u7FA4\u914D\u7F6E\u7684\u540C\u6B65\u6A21\u5F0F\uFF08\u5168\u91CF/\u589E\u91CF\uFF09",
+  "\u524D\u7F6E\uFF1A\u8BF7\u5148\u5728\u914D\u7F6E\u6587\u4EF6\u586B\u5199 openlistBaseUrl/openlistUsername/openlistPassword\u3002"
+].join("\n");
+var syncGroupFilesToOpenListCore = async (params) => {
+  const {
+    bot,
+    groupId,
+    folderId,
+    maxFiles,
+    flat,
+    targetDir,
+    mode,
+    urlConcurrency,
+    transferConcurrency,
+    fileTimeoutSec,
+    retryTimes,
+    retryDelayMs,
+    progressReportEvery,
+    downloadLimitKbps,
+    uploadLimitKbps,
+    report
+  } = params;
+  const cfg = config();
+  const baseUrl = String(cfg.openlistBaseUrl ?? "").trim();
+  const username = String(cfg.openlistUsername ?? "").trim();
+  const password = String(cfg.openlistPassword ?? "").trim();
+  const defaultTargetDir = String(cfg.openlistTargetDir ?? "/").trim();
+  if (!baseUrl || !username || !password) {
+    throw new Error([
+      "\u8BF7\u5148\u914D\u7F6E OpenList \u4FE1\u606F\uFF08openlistBaseUrl/openlistUsername/openlistPassword\uFF09",
+      `\u914D\u7F6E\u6587\u4EF6\u4F4D\u7F6E\uFF1A${dir.ConfigDir}/config.json`
+    ].join("\n"));
+  }
+  const davBaseUrl = buildOpenListDavBaseUrl(baseUrl);
+  if (!davBaseUrl) throw new Error("OpenList \u5730\u5740\u4E0D\u6B63\u786E\uFF0C\u8BF7\u68C0\u67E5 openlistBaseUrl");
+  const finalTargetDir = normalizePosixPath(targetDir || defaultTargetDir);
+  const auth = buildOpenListAuthHeader(username, password);
+  const safeFileTimeoutSec = Math.min(
+    MAX_FILE_TIMEOUT_SEC,
+    Math.max(MIN_FILE_TIMEOUT_SEC, Math.floor(fileTimeoutSec || 0))
+  );
+  const safeProgressReportEvery = Math.max(
+    0,
+    Math.floor(typeof progressReportEvery === "number" ? progressReportEvery : DEFAULT_PROGRESS_REPORT_EVERY)
+  );
+  const rateDown = Math.max(0, Math.floor(typeof downloadLimitKbps === "number" ? downloadLimitKbps : 0));
+  const rateUp = Math.max(0, Math.floor(typeof uploadLimitKbps === "number" ? uploadLimitKbps : 0));
+  const effectiveRateLimitBytesPerSec = (() => {
+    const a = rateDown > 0 ? rateDown * 1024 : 0;
+    const b = rateUp > 0 ? rateUp * 1024 : 0;
+    if (a > 0 && b > 0) return Math.min(a, b);
+    return a > 0 ? a : b > 0 ? b : 0;
+  })();
+  const transferTimeoutMs = safeFileTimeoutSec * 1e3;
+  const webdavTimeoutMs = 15e3;
+  const dirEnsurer = createWebDavDirEnsurer(davBaseUrl, auth, webdavTimeoutMs);
+  const groupContact = karin.contactGroup(groupId);
+  const state = readGroupSyncState(groupId);
+  return await withGroupSyncLock(groupId, async () => {
+    report && await report([
+      "\u5F00\u59CB\u540C\u6B65\u7FA4\u6587\u4EF6\u5230 OpenList\uFF0C\u8BF7\u7A0D\u5019...",
+      `- \u7FA4\u53F7\uFF1A${groupId}`,
+      `- \u76EE\u6807\u76EE\u5F55\uFF1A${finalTargetDir}`,
+      `- \u6A21\u5F0F\uFF1A${mode === "incremental" ? "\u589E\u91CF" : "\u5168\u91CF"}`,
+      `- \u4FDD\u7559\u76EE\u5F55\u7ED3\u6784\uFF1A${flat ? "\u5426" : "\u662F"}`,
+      `- \u5E76\u53D1\uFF1AURL ${urlConcurrency} / \u4F20\u8F93 ${transferConcurrency}`
+    ].join("\n"));
+    let list = [];
+    list = await collectAllGroupFiles(bot, groupId, folderId);
+    const limitedList = typeof maxFiles === "number" && Number.isFinite(maxFiles) && maxFiles > 0 ? list.slice(0, Math.floor(maxFiles)) : list;
+    const candidates = limitedList.map((item) => {
+      const remotePath = buildRemotePathForItem(item, finalTargetDir, flat);
+      return { item, remotePath };
+    });
+    let skipped = 0;
+    let needSync = mode === "incremental" ? candidates.filter(({ item, remotePath }) => {
+      const prev = state.files[remotePath];
+      const ok = isSameSyncedFile(prev, item);
+      if (ok) skipped++;
+      return !ok;
+    }) : candidates;
+    if (mode === "incremental" && needSync.length) {
+      const dirs = Array.from(new Set(
+        needSync.map(({ remotePath }) => normalizePosixPath(path.posix.dirname(remotePath)))
+      ));
+      const namesByDir = /* @__PURE__ */ new Map();
+      await runWithConcurrency(dirs, 3, async (dirPath) => {
+        const names = await webdavPropfindListNames({
+          davBaseUrl,
+          auth,
+          dirPath,
+          timeoutMs: webdavTimeoutMs
+        });
+        namesByDir.set(dirPath, names);
+      });
+      needSync = needSync.filter(({ remotePath }) => {
+        const dirPath = normalizePosixPath(path.posix.dirname(remotePath));
+        const base = path.posix.basename(remotePath);
+        const names = namesByDir.get(dirPath);
+        if (names && names.has(base)) {
+          skipped++;
+          return false;
+        }
+        return true;
+      });
+    }
+    if (!needSync.length) {
+      report && await report(`\u6CA1\u6709\u9700\u8981\u540C\u6B65\u7684\u6587\u4EF6\uFF08\u589E\u91CF\u6A21\u5F0F\u5DF2\u8DF3\u8FC7 ${skipped} \u6761\uFF09\u3002`);
+      return { total: limitedList.length, skipped, urlOk: 0, ok: 0, fail: 0 };
+    }
+    const urlErrors = [];
+    await runWithConcurrency(needSync, Math.max(1, Math.floor(urlConcurrency) || 1), async ({ item }) => {
+      try {
+        item.url = await resolveGroupFileUrl(bot, groupContact, groupId, item);
+      } catch (error) {
+        urlErrors.push({ fileId: item.fileId, path: item.path, message: formatErrorMessage(error) });
+      }
+    });
+    const withUrl = needSync.filter(({ item }) => typeof item.url === "string" && item.url).map((v) => v);
+    report && await report(`URL\u83B7\u53D6\u5B8C\u6210\uFF1A\u6210\u529F ${withUrl.length} / \u5931\u8D25 ${needSync.length - withUrl.length}\uFF08\u589E\u91CF\u8DF3\u8FC7 ${skipped}\uFF09`);
+    if (!withUrl.length) {
+      report && await report("\u6CA1\u6709\u53EF\u7528\u7684\u4E0B\u8F7DURL\uFF0C\u65E0\u6CD5\u540C\u6B65\u5230 OpenList");
+      return { total: limitedList.length, skipped, urlOk: 0, ok: 0, fail: 0 };
+    }
+    const syncErrors = [];
+    let okCount = 0;
+    const shouldRefreshUrl = (message) => {
+      return /403|URL已过期|url已过期|url可能已失效|需要重新获取|下载超时/.test(message);
+    };
+    const transferOne = async (sourceUrl, targetUrl) => {
+      await downloadAndUploadByWebDav({
+        sourceUrl,
+        targetUrl,
+        auth,
+        timeoutMs: transferTimeoutMs,
+        rateLimitBytesPerSec: effectiveRateLimitBytesPerSec || void 0
+      });
+    };
+    report && await report("\u5F00\u59CB\u4E0B\u8F7D\u5E76\u4E0A\u4F20\u5230 OpenList\uFF0C\u8BF7\u7A0D\u5019...");
+    const transferInitial = Math.min(MAX_TRANSFER_CONCURRENCY, Math.max(1, Math.floor(transferConcurrency) || 1));
+    const adaptiveTransfer = effectiveRateLimitBytesPerSec <= 0;
+    const transferFn = async ({ item, remotePath }, index) => {
+      logger.info(`[\u7FA4\u6587\u4EF6\u540C\u6B65][${groupId}] \u540C\u6B65\u4E2D (${index + 1}/${withUrl.length}): ${item.path}`);
+      const remoteDir = normalizePosixPath(path.posix.dirname(remotePath));
+      const targetUrl = `${davBaseUrl}${encodePathForUrl(remotePath)}`;
+      let lastError;
+      let succeeded = false;
+      const attempts = Math.max(0, Math.floor(retryTimes) || 0) + 1;
+      for (let attempt = 1; attempt <= attempts; attempt++) {
+        try {
+          await dirEnsurer.ensureDir(remoteDir);
+          const currentUrl = item.url;
+          if (!currentUrl) throw new Error("\u7F3A\u5C11\u4E0B\u8F7DURL");
+          await transferOne(currentUrl, targetUrl);
+          okCount++;
+          succeeded = true;
+          lastError = void 0;
+          state.files[remotePath] = {
+            fileId: item.fileId,
+            size: item.size,
+            uploadTime: item.uploadTime,
+            md5: item.md5,
+            sha1: item.sha1,
+            syncedAt: Date.now()
+          };
+          break;
+        } catch (error) {
+          lastError = error;
+          const msg = formatErrorMessage(error);
+          if (attempt < attempts) {
+            if (shouldRefreshUrl(msg)) {
+              try {
+                item.url = await resolveGroupFileUrl(bot, groupContact, groupId, item);
+              } catch {
+              }
+            }
+            const delay = Math.max(0, Math.floor(retryDelayMs) || 0) * Math.pow(2, attempt - 1);
+            if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay));
+            continue;
+          }
+        }
+      }
+      if (!succeeded && lastError) {
+        syncErrors.push({
+          path: item.path,
+          fileId: item.fileId,
+          message: formatErrorMessage(lastError)
+        });
+      }
+      if (safeProgressReportEvery > 0 && (index + 1) % safeProgressReportEvery === 0) {
+        report && await report(`\u540C\u6B65\u8FDB\u5EA6\uFF1A${index + 1}/${withUrl.length}\uFF08\u6210\u529F ${okCount}\uFF09`);
+      }
+    };
+    if (adaptiveTransfer) {
+      logger.info(`[\u7FA4\u6587\u4EF6\u540C\u6B65][${groupId}] \u672A\u914D\u7F6E\u9650\u901F\uFF0C\u5C06\u81EA\u9002\u5E94\u8C03\u6574\u4F20\u8F93\u5E76\u53D1\uFF08\u6700\u5927 ${MAX_TRANSFER_CONCURRENCY}\uFF09`);
+      await runWithAdaptiveConcurrency(withUrl, {
+        initial: transferInitial,
+        max: MAX_TRANSFER_CONCURRENCY,
+        fn: transferFn,
+        onAdjust: (current, reason) => {
+          logger.info(`[\u7FA4\u6587\u4EF6\u540C\u6B65][${groupId}] \u81EA\u9002\u5E94\u8C03\u6574\u4F20\u8F93\u5E76\u53D1=${current} (${reason})`);
+        }
+      });
+    } else {
+      await runWithConcurrency(withUrl, transferInitial, transferFn);
+    }
+    state.lastSyncAt = Date.now();
+    writeGroupSyncState(groupId, state);
+    const failCount = withUrl.length - okCount;
+    report && await report(`\u540C\u6B65\u5B8C\u6210\uFF1A\u6210\u529F ${okCount} / \u5931\u8D25 ${failCount}\uFF08\u589E\u91CF\u8DF3\u8FC7 ${skipped}\uFF09`);
+    if (failCount) {
+      const preview = syncErrors.slice(0, 5).map((it) => `${it.path} (${it.fileId})
+${it.message}`).join("\n\n");
+      report && await report(`\u5931\u8D25\u793A\u4F8B\uFF08\u524D5\u6761\uFF09\uFF1A
+${preview}`);
+    }
+    if (urlErrors.length) {
+      const preview = urlErrors.slice(0, 5).map((it) => `${it.path ?? ""} (${it.fileId ?? ""})
+${it.message}`).join("\n\n");
+      report && await report(`URL\u83B7\u53D6\u5931\u8D25\u793A\u4F8B\uFF08\u524D5\u6761\uFF09\uFF1A
+${preview}`);
+    }
+    return { total: limitedList.length, skipped, urlOk: withUrl.length, ok: okCount, fail: failCount };
+  });
+};
+var syncGroupFilesToOpenList = karin.command(/^#?(同步群文件|群文件同步)(.*)$/i, async (e) => {
+  if (!e.isPrivate) return false;
+  const argsText = e.msg.replace(/^#?(同步群文件|群文件同步)/i, "");
+  const {
+    groupId: parsedGroupId,
+    folderId: parsedFolderId,
+    maxFiles: parsedMaxFiles,
+    concurrency,
+    concurrencySpecified,
+    flat,
+    flatSpecified,
+    to,
+    toSpecified,
+    timeoutSec,
+    timeoutSpecified,
+    mode: forcedMode,
+    help
+  } = parseSyncArgs(argsText);
+  if (help) {
+    await e.reply(syncHelpText);
+    return true;
+  }
+  const cfg = config();
+  const groupId = parsedGroupId ?? (e.isGroup ? e.groupId : void 0);
+  if (!groupId) {
+    await e.reply(`\u7F3A\u5C11\u7FA4\u53F7\u53C2\u6570
+
+${syncHelpText}`);
+    return true;
+  }
+  const defaults = cfg.groupSyncDefaults ?? {};
+  const targetCfg = getGroupSyncTarget(cfg, groupId);
+  const mode = forcedMode ?? (targetCfg ? normalizeSyncMode(targetCfg?.mode, normalizeSyncMode(defaults?.mode, "incremental")) : "full");
+  const urlC = concurrencySpecified ? typeof concurrency === "number" ? concurrency : 3 : typeof targetCfg?.urlConcurrency === "number" ? targetCfg.urlConcurrency : typeof defaults?.urlConcurrency === "number" ? defaults.urlConcurrency : 3;
+  const transferC = concurrencySpecified ? typeof concurrency === "number" ? concurrency : 3 : typeof targetCfg?.transferConcurrency === "number" ? targetCfg.transferConcurrency : typeof defaults?.transferConcurrency === "number" ? defaults.transferConcurrency : 3;
+  const fileTimeout = timeoutSpecified ? typeof timeoutSec === "number" ? timeoutSec : 600 : typeof targetCfg?.fileTimeoutSec === "number" ? targetCfg.fileTimeoutSec : typeof defaults?.fileTimeoutSec === "number" ? defaults.fileTimeoutSec : 600;
+  const retryTimes = typeof targetCfg?.retryTimes === "number" ? targetCfg.retryTimes : typeof defaults?.retryTimes === "number" ? defaults.retryTimes : 2;
+  const retryDelayMs = typeof targetCfg?.retryDelayMs === "number" ? targetCfg.retryDelayMs : typeof defaults?.retryDelayMs === "number" ? defaults.retryDelayMs : 1500;
+  const progressEvery = typeof targetCfg?.progressReportEvery === "number" ? targetCfg.progressReportEvery : typeof defaults?.progressReportEvery === "number" ? defaults.progressReportEvery : DEFAULT_PROGRESS_REPORT_EVERY;
+  const downloadLimitKbps = typeof targetCfg?.downloadLimitKbps === "number" ? targetCfg.downloadLimitKbps : typeof defaults?.downloadLimitKbps === "number" ? defaults.downloadLimitKbps : 0;
+  const uploadLimitKbps = typeof targetCfg?.uploadLimitKbps === "number" ? targetCfg.uploadLimitKbps : typeof defaults?.uploadLimitKbps === "number" ? defaults.uploadLimitKbps : 0;
+  const targetDir = normalizePosixPath(
+    toSpecified ? to ?? "" : String(targetCfg?.targetDir ?? "").trim() || path.posix.join(String(cfg.openlistTargetDir ?? "/"), String(groupId))
+  );
+  const finalFlat = flatSpecified ? Boolean(flat) : typeof targetCfg?.flat === "boolean" ? targetCfg.flat : Boolean(defaults?.flat ?? false);
+  const folderId = parsedFolderId ?? targetCfg?.sourceFolderId;
+  const maxFiles = typeof parsedMaxFiles === "number" ? parsedMaxFiles : targetCfg?.maxFiles;
+  try {
+    await syncGroupFilesToOpenListCore({
+      bot: e.bot,
+      groupId,
+      folderId,
+      maxFiles,
+      flat: Boolean(finalFlat),
+      targetDir,
+      mode,
+      urlConcurrency: Math.max(1, Math.floor(urlC) || 1),
+      transferConcurrency: Math.max(1, Math.floor(transferC) || 1),
+      fileTimeoutSec: Math.min(MAX_FILE_TIMEOUT_SEC, Math.max(MIN_FILE_TIMEOUT_SEC, Math.floor(fileTimeout) || MIN_FILE_TIMEOUT_SEC)),
+      retryTimes: Math.max(0, Math.floor(retryTimes) || 0),
+      retryDelayMs: Math.max(0, Math.floor(retryDelayMs) || 0),
+      progressReportEvery: Math.max(0, Math.floor(progressEvery) || 0),
+      downloadLimitKbps: Math.max(0, Math.floor(downloadLimitKbps) || 0),
+      uploadLimitKbps: Math.max(0, Math.floor(uploadLimitKbps) || 0),
+      report: (msg) => e.reply(msg)
+    });
+  } catch (error) {
+    logger.error(error);
+    await e.reply(formatErrorMessage(error));
+    return true;
+  }
+  return true;
+}, {
+  priority: 9999,
+  log: true,
+  name: "\u540C\u6B65\u7FA4\u6587\u4EF6\u5230OpenList",
+  permission: "all"
+});
+var webdavPropfindListEntries = async (params) => {
+  const { davBaseUrl, auth, dirPath, timeoutMs } = params;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const url = `${davBaseUrl}${encodePathForUrl(dirPath)}`;
+    const requestPath = encodePathForUrl(dirPath).replace(/\/+$/, "");
+    const body = `<?xml version="1.0" encoding="utf-8" ?>
+<d:propfind xmlns:d="DAV:">
+  <d:prop>
+    <d:displayname />
+    <d:resourcetype />
+  </d:prop>
+</d:propfind>`;
+    const headers = {
+      Depth: "1",
+      "Content-Type": "application/xml; charset=utf-8"
+    };
+    const authHeader = String(auth ?? "").trim();
+    if (authHeader) headers.Authorization = authHeader;
+    const res = await fetch(url, {
+      method: "PROPFIND",
+      headers,
+      body,
+      redirect: "follow",
+      signal: controller.signal
+    });
+    if (!res.ok) return [];
+    const text = await res.text();
+    if (!text) return [];
+    const out = [];
+    const responseRegex = /<d:response\b[\s\S]*?<\/d:response>/gi;
+    let match;
+    while (match = responseRegex.exec(text)) {
+      const block = match[0] ?? "";
+      const hrefMatch = block.match(/<d:href>([^<]+)<\/d:href>/i);
+      if (!hrefMatch) continue;
+      const href = hrefMatch[1] ?? "";
+      const decoded = decodeURIComponent(href);
+      const cleaned = decoded.replace(/\/+$/, "");
+      if (requestPath && cleaned.endsWith(requestPath)) continue;
+      const name = cleaned.split("/").filter(Boolean).pop();
+      if (!name) continue;
+      const isDir = /<d:collection\b/i.test(block) || /\/$/.test(decoded);
+      out.push({ name, isDir });
+    }
+    const selfBase = normalizePosixPath(dirPath).split("/").filter(Boolean).pop();
+    const unique = /* @__PURE__ */ new Map();
+    for (const it of out) {
+      if (selfBase && it.name === selfBase) continue;
+      unique.set(`${it.name}::${it.isDir ? "d" : "f"}`, it);
+    }
+    return [...unique.values()];
+  } catch {
+    return [];
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var safeHostDirName = (baseUrl) => {
+  try {
+    const u = new URL(String(baseUrl));
+    const host = u.hostname || String(baseUrl);
+    const port = u.port ? `_${u.port}` : "";
+    const raw = `${host}${port}`.replaceAll(".", "_").replaceAll(":", "_");
+    return safePathSegment(raw);
+  } catch {
+    const raw = String(baseUrl ?? "").replace(/^https?:\/\//i, "").replaceAll(".", "_").replaceAll(":", "_");
+    return safePathSegment(raw);
+  }
+};
+var webdavHeadExists = async (params) => {
+  const { davBaseUrl, auth, filePath, timeoutMs } = params;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const url = `${davBaseUrl}${encodePathForUrl(filePath)}`;
+    const res = await fetch(url, {
+      method: "HEAD",
+      headers: { Authorization: auth },
+      redirect: "follow",
+      signal: controller.signal
+    });
+    return res.ok;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var copyWebDavToWebDav = async (params) => {
+  const { sourceDavBaseUrl, sourceAuth, sourcePath, targetDavBaseUrl, targetAuth, targetPath, timeoutMs } = params;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const sourceUrl = `${sourceDavBaseUrl}${encodePathForUrl(sourcePath)}`;
+    const targetUrl = `${targetDavBaseUrl}${encodePathForUrl(targetPath)}`;
+    let downloadRes;
+    try {
+      const downloadHeaders = {};
+      const authHeader = String(sourceAuth ?? "").trim();
+      if (authHeader) downloadHeaders.Authorization = authHeader;
+      downloadRes = await fetch(sourceUrl, {
+        method: "GET",
+        headers: downloadHeaders,
+        redirect: "follow",
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (isAbortError(error)) throw new Error("\u6E90\u7AEF\u8BFB\u53D6\u8D85\u65F6");
+      throw new Error(`\u6E90\u7AEF\u8BFB\u53D6\u5931\u8D25: ${formatErrorMessage(error)}`);
+    }
+    if (!downloadRes.ok) {
+      const body = await fetchTextSafely(downloadRes);
+      throw new Error(`\u6E90\u7AEF\u8BFB\u53D6\u5931\u8D25: ${downloadRes.status} ${downloadRes.statusText}${body ? ` - ${body}` : ""}`);
+    }
+    if (!downloadRes.body) throw new Error("\u6E90\u7AEF\u8BFB\u53D6\u5931\u8D25: \u54CD\u5E94\u4F53\u4E3A\u7A7A");
+    const headers = { Authorization: targetAuth };
+    const contentType = downloadRes.headers.get("content-type");
+    const contentLength = downloadRes.headers.get("content-length");
+    if (contentType) headers["Content-Type"] = contentType;
+    if (contentLength) headers["Content-Length"] = contentLength;
+    const sourceStream = Readable.fromWeb(downloadRes.body);
+    let putRes;
+    try {
+      putRes = await fetch(targetUrl, {
+        method: "PUT",
+        headers,
+        body: sourceStream,
+        // @ts-expect-error Node fetch streaming body requires duplex
+        duplex: "half",
+        redirect: "follow",
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (isAbortError(error)) throw new Error("\u76EE\u6807\u7AEF\u5199\u5165\u8D85\u65F6\uFF08\u8BF7\u68C0\u67E5\u5BF9\u7AEF OpenList \u8FDE\u63A5/\u6743\u9650\uFF09");
+      throw new Error(`\u76EE\u6807\u7AEF\u5199\u5165\u5931\u8D25: ${formatErrorMessage(error)}`);
+    }
+    if (!putRes.ok) {
+      const body = await fetchTextSafely(putRes);
+      throw new Error(`\u76EE\u6807\u7AEF\u5199\u5165\u5931\u8D25: ${putRes.status} ${putRes.statusText}${body ? ` - ${body}` : ""}`);
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var parseBackupOpenListArgs = (text) => {
+  const raw = text.trim();
+  const tokens = raw ? raw.split(/\s+/).filter(Boolean) : [];
+  const help = /(^|\s)(--help|-h|help|\?)(\s|$)/i.test(raw);
+  const first = tokens[0];
+  const sourceBaseUrl = first && /^https?:\/\//i.test(first) ? first : void 0;
+  const restRaw = sourceBaseUrl ? raw.slice(first.length).trim() : raw;
+  const srcMatch = restRaw.match(/--src\s+(\S+)/i) ?? restRaw.match(/(^|\s)src=(\S+)/i);
+  const srcDir = srcMatch ? srcMatch[srcMatch.length - 1] : void 0;
+  const srcSpecified = Boolean(srcMatch);
+  const toMatch = restRaw.match(/--to\s+(\S+)/i) ?? restRaw.match(/(^|\s)to=(\S+)/i);
+  const toDir = toMatch ? toMatch[toMatch.length - 1] : void 0;
+  const toSpecified = Boolean(toMatch);
+  const maxMatch = restRaw.match(/--max\s+(\d+)/i) ?? restRaw.match(/(^|\s)max=(\d+)/i);
+  const maxFiles = maxMatch ? Number(maxMatch[maxMatch.length - 1]) : void 0;
+  const concurrencyMatch = restRaw.match(/--concurrency\s+(\d+)/i) ?? restRaw.match(/(^|\s)concurrency=(\d+)/i);
+  const concurrency = concurrencyMatch ? Number(concurrencyMatch[concurrencyMatch.length - 1]) : void 0;
+  const concurrencySpecified = Boolean(concurrencyMatch);
+  const timeoutMatch = restRaw.match(/--timeout\s+(\d+)/i) ?? restRaw.match(/(^|\s)timeout=(\d+)/i);
+  const timeoutSec = timeoutMatch ? Number(timeoutMatch[timeoutMatch.length - 1]) : void 0;
+  const timeoutSpecified = Boolean(timeoutMatch);
+  const scanMatch = restRaw.match(/--scan(?:-concurrency)?\s+(\d+)/i) ?? restRaw.match(/(^|\s)scan=(\d+)/i) ?? restRaw.match(/(^|\s)scanConcurrency=(\d+)/i) ?? restRaw.match(/(^|\s)scan_concurrency=(\d+)/i);
+  const scanConcurrency = scanMatch ? Number(scanMatch[scanMatch.length - 1]) : void 0;
+  const scanConcurrencySpecified = Boolean(scanMatch);
+  const perPageMatch = restRaw.match(/--per-page\s+(\d+)/i) ?? restRaw.match(/--perpage\s+(\d+)/i) ?? restRaw.match(/--page-size\s+(\d+)/i) ?? restRaw.match(/(^|\s)per[_-]?page=(\d+)/i) ?? restRaw.match(/(^|\s)pageSize=(\d+)/i) ?? restRaw.match(/(^|\s)per_page=(\d+)/i);
+  const perPage = perPageMatch ? Number(perPageMatch[perPageMatch.length - 1]) : void 0;
+  const perPageSpecified = Boolean(perPageMatch);
+  const modeFull = /(^|\s)(--full|full)(\s|$)/i.test(restRaw);
+  const modeInc = /(^|\s)(--inc|--incremental|inc|incremental)(\s|$)/i.test(restRaw);
+  const mode = modeFull ? "full" : modeInc ? "incremental" : void 0;
+  const transportApi = /(^|\s)(--api)(\s|$)/i.test(restRaw);
+  const transportWebDav = /(^|\s)(--webdav|--dav)(\s|$)/i.test(restRaw);
+  const transportAuto = /(^|\s)(--auto)(\s|$)/i.test(restRaw);
+  const transportSpecified = transportApi || transportWebDav || transportAuto;
+  const transport = transportApi ? "api" : transportWebDav ? "webdav" : transportAuto ? "auto" : void 0;
+  return {
+    sourceBaseUrl,
+    srcDir,
+    srcSpecified,
+    toDir,
+    toSpecified,
+    maxFiles,
+    concurrency,
+    concurrencySpecified,
+    timeoutSec,
+    timeoutSpecified,
+    scanConcurrency,
+    scanConcurrencySpecified,
+    perPage,
+    perPageSpecified,
+    mode,
+    transport,
+    transportSpecified,
+    help
+  };
+};
+var openListToOpenListHelpText = [
+  "OpenList -> OpenList \u5907\u4EFD\u7528\u6CD5\uFF1A",
+  "- \u79C1\u804A\uFF1A#\u5907\u4EFDoplist [\u6E90OpenList\u5730\u5740] [\u53C2\u6570]",
+  "- \u793A\u4F8B\uFF1A#\u5907\u4EFDoplist https://pan.example.com",
+  "- #\u5907\u4EFDoplist https://pan.example.com --src / --to /backup --inc",
+  "- #\u5907\u4EFDoplist https://pan.example.com --api",
+  "- #\u5907\u4EFDoplist https://pan.example.com --webdav",
+  "- #\u5907\u4EFDoplist https://pan.example.com --full --concurrency 3 --timeout 600",
+  "- #\u5907\u4EFDoplist https://pan.example.com --scan 30 --per-page 2000",
+  "\u63D0\u793A\uFF1A\u5907\u4EFD\u76EE\u7684\u7AEF\u4F7F\u7528 openlistBaseUrl/openlistUsername/openlistPassword\uFF08\u4E0E\u7FA4\u6587\u4EF6\u5907\u4EFD/\u540C\u6B65\u5171\u7528\uFF09\u3002",
+  "\u63D0\u793A\uFF1A\u4F20\u8F93\u9ED8\u8BA4 auto\uFF08\u4E0B\u8F7D\u8D70 API\uFF0C\u4E0A\u4F20\u8D70 WebDAV\uFF1B\u5931\u8D25\u81EA\u52A8\u56DE\u9000\u5230\u53EF\u7528\u65B9\u5F0F\uFF09\u3002",
+  "\u63D0\u793A\uFF1A--scan \u53EA\u5F71\u54CD\u201C\u83B7\u53D6\u6587\u4EF6\u5217\u8868\u201D\u7684\u5E76\u53D1\uFF1B--per-page \u53EA\u5F71\u54CD\u6E90\u7AEF\u5217\u8868\u8D70 API \u65F6\u7684\u6BCF\u9875\u6570\u91CF\uFF08\u503C\u8D8A\u5927\u8D8A\u5FEB\uFF0C\u4F46\u53EF\u80FD\u66F4\u5403\u5185\u5B58/\u66F4\u5BB9\u6613\u88AB\u9650\u6D41\uFF09\u3002",
+  '\u8BF4\u660E\uFF1A\u4F1A\u5728\u76EE\u7684\u7AEF\u76EE\u6807\u76EE\u5F55\u4E0B\u521B\u5EFA\u5B50\u76EE\u5F55\uFF08\u6E90 OpenList \u57DF\u540D\uFF0C"." \u66FF\u6362\u4E3A "_"\uFF09\uFF0C\u5E76\u540C\u6B65\u5176\u4E0B\u6240\u6709\u6587\u4EF6\u3002'
+].join("\n");
+var activeOpenListBackup = /* @__PURE__ */ new Set();
+var backupOpenListToOpenList = karin.command(/^#?备份oplist(.*)$/i, async (e) => {
+  if (!e.isPrivate) return false;
+  const argsText = e.msg.replace(/^#?备份oplist/i, "");
+  const {
+    sourceBaseUrl: sourceBaseUrlArg,
+    srcDir,
+    srcSpecified,
+    toDir,
+    toSpecified,
+    maxFiles,
+    concurrency,
+    concurrencySpecified,
+    timeoutSec,
+    timeoutSpecified,
+    scanConcurrency: scanConcurrencyArg,
+    scanConcurrencySpecified,
+    perPage: perPageArg,
+    perPageSpecified,
+    mode: forcedMode,
+    transport: forcedTransport,
+    transportSpecified,
+    help
+  } = parseBackupOpenListArgs(argsText);
+  if (help) {
+    await e.reply(openListToOpenListHelpText);
+    return true;
+  }
+  const cfg = config();
+  const sourceBaseUrl = String(sourceBaseUrlArg ?? "").trim();
+  const targetBaseUrl = String(cfg.openlistBaseUrl ?? "").trim();
+  const targetUsername = String(cfg.openlistUsername ?? "").trim();
+  const targetPassword = String(cfg.openlistPassword ?? "").trim();
+  if (!sourceBaseUrl) {
+    await e.reply(openListToOpenListHelpText);
+    return true;
+  }
+  if (!targetBaseUrl || !targetUsername || !targetPassword) {
+    await e.reply("\u8BF7\u5148\u914D\u7F6E\u76EE\u7684\u7AEF OpenList \u4FE1\u606F\uFF08openlistBaseUrl/openlistUsername/openlistPassword\uFF09");
+    return true;
+  }
+  const srcDavBaseUrl = buildOpenListDavBaseUrl(sourceBaseUrl);
+  const targetDavBaseUrl = buildOpenListDavBaseUrl(targetBaseUrl);
+  if (!srcDavBaseUrl) {
+    await e.reply("\u6E90 OpenList \u5730\u5740\u4E0D\u6B63\u786E\uFF0C\u8BF7\u68C0\u67E5\u547D\u4EE4\u53C2\u6570");
+    return true;
+  }
+  if (!targetDavBaseUrl) {
+    await e.reply("\u76EE\u7684\u7AEF OpenList \u5730\u5740\u4E0D\u6B63\u786E\uFF0C\u8BF7\u68C0\u67E5 openlistBaseUrl");
+    return true;
+  }
+  const srcAuth = "";
+  const targetAuth = buildOpenListAuthHeader(targetUsername, targetPassword);
+  const transport = forcedTransport ?? "auto";
+  const mode = forcedMode ?? "incremental";
+  const copyConcurrency = concurrencySpecified ? typeof concurrency === "number" ? concurrency : 3 : 3;
+  const fileTimeout = timeoutSpecified ? typeof timeoutSec === "number" ? timeoutSec : 600 : 600;
+  const normalizedSrcDir = normalizePosixPath(srcSpecified ? srcDir ?? "" : "/");
+  const normalizedTargetBaseDir = normalizePosixPath(
+    toSpecified ? toDir ?? "" : String(cfg.openlistTargetDir ?? "/").trim() || "/"
+  );
+  const targetRoot = normalizePosixPath(path.posix.join(normalizedTargetBaseDir, safeHostDirName(sourceBaseUrl)));
+  const lockKey = `${sourceBaseUrl} -> ${targetBaseUrl}`;
+  if (activeOpenListBackup.has(lockKey)) {
+    await e.reply("\u5907\u4EFD\u4EFB\u52A1\u6B63\u5728\u8FDB\u884C\u4E2D\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002");
+    return true;
+  }
+  let ticker;
+  let tickChain = Promise.resolve();
+  activeOpenListBackup.add(lockKey);
+  try {
+    await e.reply([
+      "\u5F00\u59CB\u5907\u4EFD OpenList...",
+      `\u6E90\uFF1A${sourceBaseUrl}`,
+      `\u6E90\u76EE\u5F55\uFF1A${normalizedSrcDir}`,
+      `\u76EE\u7684\u7AEF\uFF1A${targetBaseUrl}`,
+      `\u76EE\u7684\u7AEF\u76EE\u5F55\uFF1A${targetRoot}`,
+      `\u6A21\u5F0F\uFF1A${mode}`,
+      `\u4F20\u8F93\uFF1A${transport}`
+    ].join("\n"));
+    const timeoutMs = Math.min(MAX_FILE_TIMEOUT_SEC, Math.max(MIN_FILE_TIMEOUT_SEC, Math.floor(fileTimeout) || MIN_FILE_TIMEOUT_SEC)) * 1e3;
+    const listTimeoutMs = Math.min(15e3, timeoutMs);
+    const listPerPage = perPageSpecified ? Math.max(1, Math.min(5e3, Math.floor(perPageArg || 0) || 1e3)) : 1e3;
+    const allowAutoFallback = transport === "auto";
+    let sourceTransport = transport === "webdav" ? "webdav" : "api";
+    let targetTransport = transport === "api" ? "api" : "webdav";
+    let sourceToken;
+    let targetToken;
+    let targetTokenPromise;
+    const getSourceToken = async () => {
+      if (typeof sourceToken === "string") return sourceToken;
+      sourceToken = "";
+      return sourceToken;
+    };
+    const getTargetToken = async () => {
+      if (typeof targetToken === "string") return targetToken;
+      if (targetTokenPromise) return await targetTokenPromise;
+      targetTokenPromise = openlistApiLogin({
+        baseUrl: targetBaseUrl,
+        username: targetUsername,
+        password: targetPassword,
+        timeoutMs: listTimeoutMs
+      }).then((token) => {
+        targetToken = token;
+        return token;
+      }).catch((error) => {
+        targetTokenPromise = void 0;
+        throw error;
+      });
+      return await targetTokenPromise;
+    };
+    const targetDirEnsurerWebDav = createWebDavDirEnsurer(targetDavBaseUrl, targetAuth, timeoutMs);
+    let targetDirEnsurerApi;
+    const getTargetDirEnsurerApi = async () => {
+      if (targetDirEnsurerApi) return targetDirEnsurerApi;
+      const token = await getTargetToken();
+      targetDirEnsurerApi = createOpenListApiDirEnsurer(targetBaseUrl, token, timeoutMs);
+      return targetDirEnsurerApi;
+    };
+    const ensureTargetDir = async (dirPath) => {
+      let webdavError;
+      if (targetTransport === "webdav") {
+        try {
+          await retryAsync(() => targetDirEnsurerWebDav.ensureDir(dirPath), { retries: 2, isRetryable: isRetryableWebDavError });
+          return;
+        } catch (error) {
+          webdavError = error;
+          if (!allowAutoFallback) throw error;
+          targetTransport = "api";
+        }
+      }
+      const ensurer = await getTargetDirEnsurerApi();
+      try {
+        await retryAsync(() => ensurer.ensureDir(dirPath), { retries: 2, isRetryable: isRetryableWebDavError });
+      } catch (error) {
+        if (webdavError) {
+          throw new Error([
+            `\u76EE\u6807\u7AEF WebDAV \u4E0D\u53EF\u7528\uFF0C\u5DF2\u56DE\u9000\u5230 OpenList API\uFF0C\u4F46\u4ECD\u5931\u8D25\u3002`,
+            `\u76EE\u6807\uFF1A${targetBaseUrl}`,
+            `\u76EE\u5F55\uFF1A${dirPath}`,
+            `WebDAV: ${formatErrorMessage(webdavError)}`,
+            `API: ${formatErrorMessage(error)}`,
+            "\u8BF7\u68C0\u67E5 openlistUsername/openlistPassword \u662F\u5426\u6B63\u786E\uFF0C\u6216\u5728\u76EE\u7684\u7AEF\u542F\u7528 WebDAV \u7BA1\u7406/\u653E\u884C MKCOL/PUT\u3002"
+          ].join("\n"));
+        }
+        throw error;
+      }
+    };
+    const files = [];
+    const visited = /* @__PURE__ */ new Set();
+    const stack = [normalizedSrcDir];
+    let scannedDirs = 0;
+    const max = typeof maxFiles === "number" && Number.isFinite(maxFiles) && maxFiles > 0 ? Math.floor(maxFiles) : 0;
+    let ok = 0;
+    let skipped = 0;
+    let fail = 0;
+    let phase = "scan";
+    const startedAt = Date.now();
+    ticker = setInterval(() => {
+      const elapsed = Math.max(0, Math.floor((Date.now() - startedAt) / 1e3));
+      const msg = phase === "scan" ? `\u5907\u4EFD\u8FDB\u884C\u4E2D\uFF08${elapsed}s\uFF09
+\u9636\u6BB5\uFF1A\u626B\u63CF
+\u5DF2\u626B\u63CF\u76EE\u5F55\uFF1A${scannedDirs}
+\u5DF2\u53D1\u73B0\u6587\u4EF6\uFF1A${files.length}` : `\u5907\u4EFD\u8FDB\u884C\u4E2D\uFF08${elapsed}s\uFF09
+\u9636\u6BB5\uFF1A\u590D\u5236
+\u8FDB\u5EA6\uFF1A${ok + skipped + fail}/${files.length}
+\u6210\u529F ${ok} \u8DF3\u8FC7 ${skipped} \u5931\u8D25 ${fail}`;
+      tickChain = tickChain.then(() => e.reply(msg)).catch(() => void 0);
+    }, 6e4);
+    const maxScanConcurrency = scanConcurrencySpecified ? Math.max(1, Math.min(200, Math.floor(scanConcurrencyArg || 0) || 1)) : 50;
+    let scanConcurrency = scanConcurrencySpecified ? maxScanConcurrency : Math.max(1, Math.min(maxScanConcurrency, Math.max(8, (Math.floor(copyConcurrency) || 1) * 3)));
+    const scanResults = [];
+    const pushScanResult = (ok2, ms, reason) => {
+      scanResults.push({ ok: ok2, ms, reason });
+      if (scanResults.length > 20) scanResults.shift();
+      if (scanResults.length < 10) return;
+      if (scanResults.length % 5 !== 0) return;
+      const failCount = scanResults.filter((r) => !r.ok).length;
+      const failRate = failCount / scanResults.length;
+      const avgMs = scanResults.reduce((acc, r) => acc + r.ms, 0) / scanResults.length;
+      const hasTimeout = scanResults.some((r) => (r.reason || "").includes("\u8D85\u65F6"));
+      if (hasTimeout || failRate >= 0.2) {
+        if (scanConcurrency > 1) scanConcurrency -= 1;
+        return;
+      }
+      if (failCount === 0 && scanConcurrency < maxScanConcurrency) {
+        if (avgMs < 6e4 || scanResults.length === 20) scanConcurrency += 1;
+      }
+    };
+    let stopScan = false;
+    let scanError;
+    const isRetryableListError = (error) => {
+      const msg = formatErrorMessage(error);
+      return /超时|timeout|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|ECONNREFUSED|UND_ERR|socket hang up|\b429\b|\b5\d\d\b/i.test(msg);
+    };
+    const listDirEntries = async (dirPath) => {
+      return await retryAsync(async () => {
+        return sourceTransport === "webdav" ? await webdavPropfindListEntries({
+          davBaseUrl: srcDavBaseUrl,
+          auth: srcAuth,
+          dirPath,
+          timeoutMs: listTimeoutMs
+        }) : await openlistApiListEntries({
+          baseUrl: sourceBaseUrl,
+          token: await getSourceToken(),
+          dirPath,
+          timeoutMs: listTimeoutMs,
+          perPage: listPerPage
+        });
+      }, { retries: 2, isRetryable: isRetryableListError });
+    };
+    let scanning = 0;
+    let resolveScanDone;
+    const scanDone = new Promise((resolve) => {
+      resolveScanDone = resolve;
+    });
+    const scheduleScan = () => {
+      while (!stopScan && scanning < scanConcurrency) {
+        const rawPath = stack.pop();
+        if (!rawPath) break;
+        const current = normalizePosixPath(rawPath);
+        if (visited.has(current)) continue;
+        visited.add(current);
+        scannedDirs++;
+        scanning++;
+        (async () => {
+          const start = Date.now();
+          try {
+            const entries = await listDirEntries(current);
+            pushScanResult(true, Date.now() - start);
+            for (const entry of entries) {
+              if (stopScan) break;
+              const childPath = normalizePosixPath(path.posix.join(current, entry.name));
+              if (entry.isDir) {
+                if (!visited.has(childPath)) stack.push(childPath);
+                continue;
+              }
+              files.push(childPath);
+              if (max > 0 && files.length >= max) {
+                stopScan = true;
+                break;
+              }
+            }
+          } catch (error) {
+            pushScanResult(false, Date.now() - start, formatErrorMessage(error));
+            throw error;
+          }
+          scheduleScan();
+        })().catch((error) => {
+          scanError = error;
+          stopScan = true;
+        }).finally(() => {
+          scanning--;
+          scheduleScan();
+          if ((stopScan || stack.length === 0) && scanning === 0) resolveScanDone?.();
+        });
+      }
+      if ((stopScan || stack.length === 0) && scanning === 0) resolveScanDone?.();
+    };
+    scheduleScan();
+    await scanDone;
+    if (scanError) throw scanError;
+    if (!files.length) {
+      await e.reply("\u672A\u53D1\u73B0\u53EF\u5907\u4EFD\u7684\u6587\u4EF6\uFF08\u6E90\u76EE\u5F55\u4E3A\u7A7A\u6216\u65E0\u6CD5\u8BBF\u95EE\uFF09\u3002");
+      return true;
+    }
+    phase = "copy";
+    await ensureTargetDir(targetRoot);
+    await e.reply(`\u5DF2\u53D1\u73B0 ${files.length} \u4E2A\u6587\u4EF6\uFF0C\u5F00\u59CB\u590D\u5236...`);
+    const limit = Math.max(1, Math.min(MAX_TRANSFER_CONCURRENCY, Math.floor(copyConcurrency) || 1));
+    await runWithConcurrency(files, limit, async (sourcePath, index) => {
+      const rel = path.posix.relative(normalizedSrcDir, sourcePath);
+      const relParts = rel.split("/").filter(Boolean).map(safePathSegment);
+      const targetPath = normalizePosixPath(path.posix.join(targetRoot, ...relParts));
+      const targetDirPath = normalizePosixPath(path.posix.dirname(targetPath));
+      if (mode === "incremental") {
+        const exists = targetTransport === "webdav" ? await webdavHeadExists({
+          davBaseUrl: targetDavBaseUrl,
+          auth: targetAuth,
+          filePath: targetPath,
+          timeoutMs: Math.max(5e3, Math.floor(timeoutMs / 5))
+        }) : await openlistApiPathExists({
+          baseUrl: targetBaseUrl,
+          token: await getTargetToken(),
+          path: targetPath,
+          timeoutMs: Math.max(5e3, Math.floor(timeoutMs / 5))
+        });
+        if (exists) {
+          skipped++;
+          return;
+        }
+      }
+      try {
+        await ensureTargetDir(targetDirPath);
+        if (sourceTransport === "webdav" && targetTransport === "webdav") {
+          await copyWebDavToWebDav({
+            sourceDavBaseUrl: srcDavBaseUrl,
+            sourceAuth: srcAuth,
+            sourcePath,
+            targetDavBaseUrl,
+            targetAuth,
+            targetPath,
+            timeoutMs
+          });
+        } else if (sourceTransport === "webdav" && targetTransport === "api") {
+          await downloadAndUploadByOpenListApiPut({
+            sourceUrl: `${srcDavBaseUrl}${encodePathForUrl(sourcePath)}`,
+            sourceHeaders: srcAuth ? { Authorization: srcAuth } : void 0,
+            targetBaseUrl,
+            targetToken: await getTargetToken(),
+            targetPath,
+            timeoutMs
+          });
+        } else if (sourceTransport === "api" && targetTransport === "webdav") {
+          const token = await getSourceToken();
+          const rawUrl = await openlistApiGetRawUrl({
+            baseUrl: sourceBaseUrl,
+            token,
+            filePath: sourcePath,
+            timeoutMs: Math.max(5e3, Math.floor(timeoutMs / 5))
+          });
+          const sourceHeaders = buildOpenListRawUrlAuthHeaders({ rawUrl, baseUrl: sourceBaseUrl, token });
+          await downloadAndUploadByWebDav({
+            sourceUrl: rawUrl,
+            sourceHeaders,
+            targetUrl: `${targetDavBaseUrl}${encodePathForUrl(targetPath)}`,
+            auth: targetAuth,
+            timeoutMs
+          });
+        } else {
+          const token = await getSourceToken();
+          const rawUrl = await openlistApiGetRawUrl({
+            baseUrl: sourceBaseUrl,
+            token,
+            filePath: sourcePath,
+            timeoutMs: Math.max(5e3, Math.floor(timeoutMs / 5))
+          });
+          const sourceHeaders = buildOpenListRawUrlAuthHeaders({ rawUrl, baseUrl: sourceBaseUrl, token });
+          await downloadAndUploadByOpenListApiPut({
+            sourceUrl: rawUrl,
+            sourceHeaders,
+            targetBaseUrl,
+            targetToken: await getTargetToken(),
+            targetPath,
+            timeoutMs
+          });
+        }
+        ok++;
+      } catch (error) {
+        fail++;
+        logger.error(error);
+      }
+    });
+    await e.reply(`\u5907\u4EFD\u5B8C\u6210\uFF1A\u6210\u529F ${ok}\uFF0C\u8DF3\u8FC7 ${skipped}\uFF0C\u5931\u8D25 ${fail}`);
+    return true;
+  } catch (error) {
+    logger.error(error);
+    await e.reply(formatErrorMessage(error));
+    return true;
+  } finally {
+    if (ticker) clearInterval(ticker);
+    await tickChain.catch(() => void 0);
+    activeOpenListBackup.delete(lockKey);
+  }
+}, {
+  priority: 9999,
+  log: true,
+  name: "OpenList\u5907\u4EFD\u5230\u5BF9\u7AEFOpenList",
+  permission: "all"
+});
+var activeGroupFileUploadBackups = /* @__PURE__ */ new Map();
+var uploadBackupSkipLoggedGroups = /* @__PURE__ */ new Set();
+var uploadBackupUrlFallbackLoggedGroups = /* @__PURE__ */ new Set();
+var enqueueGroupFileUploadBackup = (groupId, task) => {
+  const key = String(groupId);
+  const previous = activeGroupFileUploadBackups.get(key) ?? Promise.resolve();
+  const nextTask = previous.catch(() => void 0).then(task);
+  activeGroupFileUploadBackups.set(key, nextTask);
+  nextTask.finally(() => {
+    if (activeGroupFileUploadBackups.get(key) === nextTask) activeGroupFileUploadBackups.delete(key);
+  });
+};
+var groupFileUploadedAutoBackup = karin.accept("notice.groupFileUploaded", (e, next) => {
+  try {
+    const groupId = String(e?.groupId ?? "").trim();
+    if (!groupId) return;
+    const cfg = config();
+    const targetCfg = getGroupSyncTarget(cfg, groupId);
+    const uploadBackupEnabled = targetCfg?.uploadBackup === true || ["true", "1", "on"].includes(String(targetCfg?.uploadBackup ?? "").trim().toLowerCase());
+    if (!targetCfg || targetCfg.enabled === false || !uploadBackupEnabled) {
+      if (!uploadBackupSkipLoggedGroups.has(groupId)) {
+        uploadBackupSkipLoggedGroups.add(groupId);
+        logger.info(`[\u7FA4\u4E0A\u4F20\u5907\u4EFD][${groupId}] uploadBackup \u672A\u542F\u7528\u6216\u8BE5\u7FA4\u672A\u914D\u7F6E\uFF0C\u5DF2\u8DF3\u8FC7\uFF08\u53EF\u5728 WebUI \u5F00\u542F uploadBackup\uFF09`);
+      }
+      return;
+    }
+    const file = e.content;
+    const fid = String(file?.fid ?? "").trim();
+    const name = String(file?.name ?? "").trim();
+    const size = typeof file?.size === "number" && Number.isFinite(file.size) ? Math.max(0, Math.floor(file.size)) : void 0;
+    const getUrl = typeof file?.url === "function" ? file.url : null;
+    if (!fid || !name || !getUrl) {
+      logger.warn(`[\u7FA4\u4E0A\u4F20\u5907\u4EFD][${groupId}] \u7FA4\u6587\u4EF6\u4E0A\u4F20\u4E8B\u4EF6\u7F3A\u5C11\u5FC5\u8981\u5B57\u6BB5\uFF08fid/name/url\uFF09\uFF0C\u5DF2\u8DF3\u8FC7`);
+      return;
+    }
+    enqueueGroupFileUploadBackup(groupId, async () => {
+      const baseUrl = String(cfg.openlistBaseUrl ?? "").trim();
+      const username = String(cfg.openlistUsername ?? "").trim();
+      const password = String(cfg.openlistPassword ?? "").trim();
+      const defaultTargetDir = String(cfg.openlistTargetDir ?? "/").trim();
+      if (!baseUrl || !username || !password) {
+        logger.error(`[\u7FA4\u4E0A\u4F20\u5907\u4EFD][${groupId}] \u7F3A\u5C11 OpenList \u914D\u7F6E\uFF08openlistBaseUrl/openlistUsername/openlistPassword\uFF09`);
+        return;
+      }
+      const davBaseUrl = buildOpenListDavBaseUrl(baseUrl);
+      if (!davBaseUrl) {
+        logger.error(`[\u7FA4\u4E0A\u4F20\u5907\u4EFD][${groupId}] OpenList \u5730\u5740\u4E0D\u6B63\u786E\uFF0C\u8BF7\u68C0\u67E5 openlistBaseUrl`);
+        return;
+      }
+      const defaults = cfg.groupSyncDefaults ?? {};
+      const targetDir = normalizePosixPath(
+        String(targetCfg?.targetDir ?? "").trim() || path.posix.join(String(defaultTargetDir || "/"), String(groupId))
+      );
+      const flat = typeof targetCfg?.flat === "boolean" ? targetCfg.flat : Boolean(defaults?.flat ?? false);
+      const item = {
+        path: name,
+        fileId: fid,
+        name,
+        size,
+        busid: typeof file?.subId === "number" && Number.isFinite(file.subId) ? Math.floor(file.subId) : void 0
+      };
+      if (!flat) {
+        const direct = pickFirstString(file?.path, file?.filePath, file?.file_path, file?.fullPath, file?.full_path);
+        const normalized = direct ? normalizeGroupFileRelativePath(direct) : "";
+        if (normalized) item.path = normalized;
+        const bot = e?.bot;
+        if (bot && !item.path.includes("/")) {
+          try {
+            const found = await locateGroupFileByIdWithRetry(bot, groupId, fid, {
+              retries: 3,
+              delayMs: 1200,
+              timeoutMs: 15e3,
+              maxFolders: 4e3,
+              expectedName: name,
+              expectedSize: size
+            });
+            if (found?.path) item.path = found.path;
+            if (typeof found?.busid === "number" && Number.isFinite(found.busid)) item.busid = Math.floor(found.busid);
+            if (!found?.path) {
+              logger.warn(`[\u7FA4\u4E0A\u4F20\u5907\u4EFD][${groupId}] \u672A\u80FD\u89E3\u6790\u7FA4\u6587\u4EF6\u5939\u8DEF\u5F84\uFF0C\u53EF\u80FD\u534F\u8BAE\u7AEF\u672A\u63D0\u4F9B\u76EE\u5F55\u4FE1\u606F\u6216\u6587\u4EF6\u5C1A\u672A\u5165\u5E93\uFF0C\u5C06\u5907\u4EFD\u5230\u7FA4\u6839\u76EE\u5F55\uFF1A${name}`);
+            }
+          } catch (error) {
+            logger.debug(`[\u7FA4\u4E0A\u4F20\u5907\u4EFD][${groupId}] \u83B7\u53D6\u7FA4\u5185\u6587\u4EF6\u8DEF\u5F84\u5931\u8D25\uFF0C\u5C06\u9000\u5316\u4E3A\u6839\u76EE\u5F55: ${formatErrorMessage(error)}`);
+          }
+        }
+      }
+      const resolveUrl = async () => {
+        try {
+          const url2 = await getUrl();
+          if (typeof url2 === "string" && url2.trim()) return url2.trim();
+        } catch {
+        }
+        const bot = e?.bot;
+        const contact = e?.contact;
+        if (!bot) throw new Error("\u4E8B\u4EF6\u5BF9\u8C61\u7F3A\u5C11 bot\uFF0C\u65E0\u6CD5\u901A\u8FC7\u63A5\u53E3\u83B7\u53D6\u4E0B\u8F7DURL");
+        const url = await resolveGroupFileUrl(bot, contact, groupId, item);
+        if (typeof url === "string" && url.trim()) {
+          if (!uploadBackupUrlFallbackLoggedGroups.has(groupId)) {
+            uploadBackupUrlFallbackLoggedGroups.add(groupId);
+            logger.debug(`[\u7FA4\u4E0A\u4F20\u5907\u4EFD][${groupId}] file.url() \u4E0D\u53EF\u7528\uFF0C\u5DF2\u81EA\u52A8\u4F7F\u7528\u63A5\u53E3\u83B7\u53D6\u4E0B\u8F7DURL\uFF08\u8BE5\u63D0\u793A\u4EC5\u51FA\u73B0\u4E00\u6B21\uFF09`);
+          }
+          return url.trim();
+        }
+        throw new Error("\u901A\u8FC7\u63A5\u53E3\u83B7\u53D6\u4E0B\u8F7DURL\u5931\u8D25");
+      };
+      const remotePath = buildRemotePathForItem(item, targetDir, flat);
+      const remoteDir = normalizePosixPath(path.posix.dirname(remotePath));
+      const state = readGroupSyncState(groupId);
+      if (state.files?.[remotePath]?.fileId && String(state.files[remotePath].fileId) === fid) {
+        logger.info(`[\u7FA4\u4E0A\u4F20\u5907\u4EFD][${groupId}] \u5DF2\u5907\u4EFD\uFF0C\u8DF3\u8FC7: ${name} (${fid})`);
+        return;
+      }
+      const auth = buildOpenListAuthHeader(username, password);
+      const fileTimeoutSec = typeof targetCfg?.fileTimeoutSec === "number" ? targetCfg.fileTimeoutSec : typeof defaults?.fileTimeoutSec === "number" ? defaults.fileTimeoutSec : 600;
+      const safeFileTimeoutSec = Math.min(
+        MAX_FILE_TIMEOUT_SEC,
+        Math.max(MIN_FILE_TIMEOUT_SEC, Math.floor(fileTimeoutSec || 0))
+      );
+      const rateDown = Math.max(0, Math.floor(typeof targetCfg?.downloadLimitKbps === "number" ? targetCfg.downloadLimitKbps : typeof defaults?.downloadLimitKbps === "number" ? defaults.downloadLimitKbps : 0));
+      const rateUp = Math.max(0, Math.floor(typeof targetCfg?.uploadLimitKbps === "number" ? targetCfg.uploadLimitKbps : typeof defaults?.uploadLimitKbps === "number" ? defaults.uploadLimitKbps : 0));
+      const effectiveRateLimitBytesPerSec = (() => {
+        const a = rateDown > 0 ? rateDown * 1024 : 0;
+        const b = rateUp > 0 ? rateUp * 1024 : 0;
+        if (a > 0 && b > 0) return Math.min(a, b);
+        return a > 0 ? a : b > 0 ? b : 0;
+      })();
+      const retryTimes = typeof targetCfg?.retryTimes === "number" ? targetCfg.retryTimes : typeof defaults?.retryTimes === "number" ? defaults.retryTimes : 2;
+      const retryDelayMs = typeof targetCfg?.retryDelayMs === "number" ? targetCfg.retryDelayMs : typeof defaults?.retryDelayMs === "number" ? defaults.retryDelayMs : 1500;
+      const transferTimeoutMs = safeFileTimeoutSec * 1e3;
+      const webdavTimeoutMs = 15e3;
+      const dirEnsurer = createWebDavDirEnsurer(davBaseUrl, auth, webdavTimeoutMs);
+      const targetUrl = `${davBaseUrl}${encodePathForUrl(remotePath)}`;
+      logger.info(`[\u7FA4\u4E0A\u4F20\u5907\u4EFD][${groupId}] \u5F00\u59CB: ${name} (${fid}) -> ${remotePath}`);
+      let lastError;
+      const attempts = Math.max(0, Math.floor(retryTimes) || 0) + 1;
+      for (let attempt = 1; attempt <= attempts; attempt++) {
+        try {
+          await dirEnsurer.ensureDir(remoteDir);
+          const url = await resolveUrl();
+          await downloadAndUploadByWebDav({
+            sourceUrl: url,
+            targetUrl,
+            auth,
+            timeoutMs: transferTimeoutMs,
+            rateLimitBytesPerSec: effectiveRateLimitBytesPerSec || void 0
+          });
+          state.files[remotePath] = {
+            fileId: fid,
+            size,
+            syncedAt: Date.now()
+          };
+          state.lastSyncAt = Date.now();
+          writeGroupSyncState(groupId, state);
+          logger.info(`[\u7FA4\u4E0A\u4F20\u5907\u4EFD][${groupId}] \u5B8C\u6210: ${name} -> ${remotePath}`);
+          lastError = void 0;
+          break;
+        } catch (error) {
+          lastError = error;
+          logger.error(error);
+          if (attempt < attempts) {
+            const delayMs = Math.max(0, Math.floor(retryDelayMs) || 0) * Math.pow(2, attempt - 1);
+            if (delayMs > 0) await sleep(delayMs);
+          }
+        }
+      }
+      if (lastError) {
+        logger.error(`[\u7FA4\u4E0A\u4F20\u5907\u4EFD][${groupId}] \u5931\u8D25: ${name} (${fid}) - ${formatErrorMessage(lastError)}`);
+      }
+    });
+  } catch (error) {
+    logger.error(error);
+  } finally {
+    next();
+  }
+}, { log: false, name: "\u7FA4\u6587\u4EF6\u4E0A\u4F20\u81EA\u52A8\u5907\u4EFD" });
+
+export {
+  exportGroupFiles,
+  syncGroupFilesToOpenListCore,
+  syncGroupFilesToOpenList,
+  backupOpenListToOpenList,
+  groupFileUploadedAutoBackup
+};