karin-plugin-qgroup-file2openlist 0.0.1

package/lib/chunk-QVWWPGHK.js

@@ -0,0 +1,1138 @@
+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();
+  return value || "unnamed";
+};
+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") {
+      const res = await onebot.getGroupRootFiles(groupNum);
+      return {
+        files: Array.isArray(res?.files) ? res.files : [],
+        folders: Array.isArray(res?.folders) ? res.folders : []
+      };
+    }
+    if (folderId && typeof onebot?.getGroupFilesByFolder === "function") {
+      const res = await onebot.getGroupFilesByFolder(groupNum, folderId);
+      return {
+        files: Array.isArray(res?.files) ? res.files : [],
+        folders: Array.isArray(res?.folders) ? res.folders : []
+      };
+    }
+  }
+  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 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 fetchTextSafely = async (res) => {
+  try {
+    const text = await res.text();
+    return text.slice(0, 500);
+  } catch {
+    return "";
+  }
+};
+var webdavMkcolOk = (status) => status === 201 || status === 405;
+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, targetUrl, auth, timeoutMs, rateLimitBytesPerSec } = params;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    let downloadRes;
+    try {
+      downloadRes = await fetch(sourceUrl, { 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 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) {
+    await e.reply("\u8BF7\u79C1\u804A\u4F7F\u7528\u8BE5\u547D\u4EE4\uFF0C\u5E76\u5728\u53C2\u6570\u4E2D\u6307\u5B9A\u7FA4\u53F7\n\u4F8B\u5982\uFF1A#\u5BFC\u51FA\u7FA4\u6587\u4EF6 123456");
+    return true;
+  }
+  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]",
+  "- \u7FA4\u804A\uFF1A#\u540C\u6B65\u7FA4\u6587\u4EF6\uFF08\u9ED8\u8BA4\u540C\u6B65\u672C\u7FA4\uFF1B\u5EFA\u8BAE\u5148\u5728 WebUI \u914D\u7F6E\u540C\u6B65\u5BF9\u8C61\u7FA4\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) => {
+  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;
+  }
+  if (e.isGroup) {
+    const role = e.sender?.role;
+    if (role !== "owner" && role !== "admin") {
+      await e.reply("\u8BF7\u7FA4\u7BA1\u7406\u5458\u4F7F\u7528\u8BE5\u547D\u4EE4\uFF08\u6216\u5728\u79C1\u804A\u4E2D\u64CD\u4F5C\uFF09\u3002");
+      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"
+});
+
+export {
+  exportGroupFiles,
+  syncGroupFilesToOpenListCore,
+  syncGroupFilesToOpenList
+};