karin-plugin-qgroup-file2openlist 0.0.26 → 0.0.27

package/README.md

@@ -51,6 +51,7 @@ TypeScript 插件开发流程现在更加简单，无需手动克隆模板仓库
 - `openlistUsername` / `openlistPassword`：用于 WebDAV BasicAuth 登录
 - `openlistTargetDir`：目标目录（例：`/挂载目录/QQ群文件`）
 - `resourceLimits.transferConcurrency`：全局传输并发上限（所有下载+上传共享；生产环境建议 1，避免同时传输吃满内存；<=0 不限制）
+- `resourceLimits.largeFileSpoolThresholdMB`：大文件落盘阈值（MB，默认 200；<=0 禁用；大文件会先下载到本地临时文件再上传，降低内存/缓冲压力）
 - `groupSyncDefaults`：群同步默认策略（并发、单文件超时、重试等）
 - `groupSyncTargets`：同步对象群配置（每群可单独覆盖目录/并发/同步时段等）
 

package/config/config.json

@@ -5,7 +5,8 @@
   "openlistPassword": "",
   "openlistTargetDir": "/",
   "resourceLimits": {
-    "transferConcurrency": 1
+    "transferConcurrency": 1,
+    "largeFileSpoolThresholdMB": 200
   },
   "groupSyncDefaults": {
     "mode": "incremental",

package/lib/apps/groupFiles.backup.js

@@ -6,12 +6,12 @@ import "../chunk-PBBZ5KAD.js";
 import "../chunk-QB3GSENE.js";
 import {
   handleGroupFileUploadedAutoBackup
-} from "../chunk-BWVJMEKK.js";
-import "../chunk-5QW7XYQX.js";
+} from "../chunk-R4MRR5TI.js";
+import "../chunk-DDV3OZXB.js";
 import {
   backupOpenListToOpenListCore,
   formatErrorMessage
-} from "../chunk-YVFRUAZO.js";
+} from "../chunk-GDVU2T6R.js";
 import {
   config
 } from "../chunk-DA4U55JC.js";

package/lib/apps/groupFiles.js

@@ -1,12 +1,12 @@
 import {
   exportGroupFilesToDisk,
   syncGroupFilesToOpenListCore
-} from "../chunk-BWVJMEKK.js";
-import "../chunk-5QW7XYQX.js";
+} from "../chunk-R4MRR5TI.js";
+import "../chunk-DDV3OZXB.js";
 import {
   formatErrorMessage,
   normalizePosixPath
-} from "../chunk-YVFRUAZO.js";
+} from "../chunk-GDVU2T6R.js";
 import {
   config
 } from "../chunk-DA4U55JC.js";

package/lib/apps/groupSyncConfig.js

@@ -1,9 +1,9 @@
 import {
   handleGroupSyncConfigCommand
-} from "../chunk-I2I6ZPJU.js";
-import "../chunk-BWVJMEKK.js";
-import "../chunk-5QW7XYQX.js";
-import "../chunk-YVFRUAZO.js";
+} from "../chunk-P5FZDWLZ.js";
+import "../chunk-R4MRR5TI.js";
+import "../chunk-DDV3OZXB.js";
+import "../chunk-GDVU2T6R.js";
 import "../chunk-DA4U55JC.js";
 import "../chunk-IZS467MR.js";
 

package/lib/apps/opCommands.js

@@ -5,7 +5,7 @@ import {
   resolveOpltMapping,
   withOpltUser,
   writeOpltData
-} from "../chunk-WQFR5LF3.js";
+} from "../chunk-5HRWYTEM.js";
 import {
   buildActionCard,
   replyImages
@@ -20,7 +20,7 @@ import {
   normalizePosixPath,
   readJsonSafe,
   writeJsonSafe
-} from "../chunk-YVFRUAZO.js";
+} from "../chunk-GDVU2T6R.js";
 import {
   config
 } from "../chunk-DA4U55JC.js";

package/lib/apps/ownerUi.js

@@ -4,14 +4,14 @@ import {
 import "../chunk-QB3GSENE.js";
 import {
   readGroupSyncState
-} from "../chunk-5QW7XYQX.js";
+} from "../chunk-DDV3OZXB.js";
 import {
   backupOpenListToOpenListCore,
   formatErrorMessage,
   normalizePosixPath,
   readJsonSafe,
   writeJsonSafe
-} from "../chunk-YVFRUAZO.js";
+} from "../chunk-GDVU2T6R.js";
 import "../chunk-DA4U55JC.js";
 import {
   dir

package/lib/apps/scheduler.js

@@ -1,12 +1,12 @@
 import {
   runNightlyOpltBackup
-} from "../chunk-WQFR5LF3.js";
+} from "../chunk-5HRWYTEM.js";
 import {
   runNightlyGroupBackup
-} from "../chunk-I2I6ZPJU.js";
-import "../chunk-BWVJMEKK.js";
-import "../chunk-5QW7XYQX.js";
-import "../chunk-YVFRUAZO.js";
+} from "../chunk-P5FZDWLZ.js";
+import "../chunk-R4MRR5TI.js";
+import "../chunk-DDV3OZXB.js";
+import "../chunk-GDVU2T6R.js";
 import {
   config
 } from "../chunk-DA4U55JC.js";

package/lib/{chunk-WQFR5LF3.js → chunk-5HRWYTEM.js}

@@ -4,7 +4,7 @@ import {
   normalizePosixPath,
   readJsonSafe,
   writeJsonSafe
-} from "./chunk-YVFRUAZO.js";
+} from "./chunk-GDVU2T6R.js";
 import {
   config
 } from "./chunk-DA4U55JC.js";

package/lib/{chunk-5QW7XYQX.js → chunk-DDV3OZXB.js}

@@ -1,7 +1,7 @@
 import {
   readJsonSafe,
   writeJsonSafe
-} from "./chunk-YVFRUAZO.js";
+} from "./chunk-GDVU2T6R.js";
 import {
   dir
 } from "./chunk-IZS467MR.js";

package/lib/{chunk-YVFRUAZO.js → chunk-GDVU2T6R.js}

@@ -1,6 +1,9 @@
 import {
   config
 } from "./chunk-DA4U55JC.js";
+import {
+  dir
+} from "./chunk-IZS467MR.js";
 
 // src/model/shared/path.ts
 var normalizePosixPath = (inputPath, { ensureLeadingSlash = true, stripTrailingSlash = true } = {}) => {
@@ -49,9 +52,27 @@ var fetchTextSafely = async (res, maxLen = 500) => {
   }
 };
 
-// src/model/openlist/backup.ts
+// src/model/shared/fsJson.ts
+import fs from "fs";
 import path from "path";
-import { logger as logger2 } from "node-karin";
+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");
+};
+
+// src/model/openlist/backup.ts
+import path3 from "path";
+import { logger as logger4 } from "node-karin";
 
 // src/model/shared/concurrency.ts
 var runWithConcurrency = async (items, concurrency, fn) => {
@@ -176,6 +197,7 @@ var buildOpenListAuthHeader = (username, password) => {
 };
 
 // src/model/openlist/api.ts
+import fs3 from "fs";
 import { Readable } from "stream";
 import { setTimeout as sleep } from "timers/promises";
 
@@ -247,7 +269,85 @@ var withGlobalTransferLimit = async (label, fn) => {
   }
 };
 
+// src/model/shared/transferSpool.ts
+import fs2 from "fs";
+import path2 from "path";
+import { randomUUID } from "crypto";
+import { pipeline } from "stream/promises";
+var DEFAULT_LARGE_FILE_SPOOL_THRESHOLD_MB = 200;
+var MAX_THRESHOLD_MB = 5e4;
+var cachedThresholdBytes = DEFAULT_LARGE_FILE_SPOOL_THRESHOLD_MB * 1024 * 1024;
+var cachedAt2 = 0;
+var CACHE_MS2 = 1e3;
+var clampInt2 = (value, min, max) => Math.min(max, Math.max(min, Math.floor(value)));
+var parseContentLengthHeader = (value) => {
+  const raw = String(value ?? "").trim();
+  if (!raw) return void 0;
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return void 0;
+  const v = Math.floor(n);
+  if (v <= 0) return void 0;
+  return v;
+};
+var getLargeFileSpoolThresholdBytes = () => {
+  const now = Date.now();
+  if (now - cachedAt2 < CACHE_MS2) return cachedThresholdBytes;
+  cachedAt2 = now;
+  try {
+    const cfg = config();
+    const raw = cfg?.resourceLimits?.largeFileSpoolThresholdMB;
+    if (raw === void 0 || raw === null || raw === "") {
+      cachedThresholdBytes = DEFAULT_LARGE_FILE_SPOOL_THRESHOLD_MB * 1024 * 1024;
+      return cachedThresholdBytes;
+    }
+    const n = typeof raw === "number" ? raw : Number(raw);
+    if (!Number.isFinite(n)) {
+      cachedThresholdBytes = DEFAULT_LARGE_FILE_SPOOL_THRESHOLD_MB * 1024 * 1024;
+      return cachedThresholdBytes;
+    }
+    if (n <= 0) {
+      cachedThresholdBytes = 0;
+      return cachedThresholdBytes;
+    }
+    const mb = clampInt2(n, 1, MAX_THRESHOLD_MB);
+    cachedThresholdBytes = mb * 1024 * 1024;
+    return cachedThresholdBytes;
+  } catch {
+    cachedThresholdBytes = DEFAULT_LARGE_FILE_SPOOL_THRESHOLD_MB * 1024 * 1024;
+    return cachedThresholdBytes;
+  }
+};
+var shouldSpoolToDisk = (sizeBytes) => {
+  const threshold = getLargeFileSpoolThresholdBytes();
+  if (!threshold) return false;
+  if (typeof sizeBytes !== "number" || !Number.isFinite(sizeBytes)) return false;
+  return Math.floor(sizeBytes) >= threshold;
+};
+var safeFileName = (value) => {
+  return String(value ?? "").replaceAll("\0", "").replace(/[^\w.-]+/g, "_").replace(/^_+/, "").slice(0, 50) || "transfer";
+};
+var getTransferTmpDir = () => {
+  const tmpDir = path2.join(dir.DataDir, "transfer-tmp");
+  ensureDir(tmpDir);
+  return tmpDir;
+};
+var createTransferTempFilePath = (prefix) => {
+  const tmpDir = getTransferTmpDir();
+  const name = `${safeFileName(prefix)}-${Date.now()}-${randomUUID()}.tmp`;
+  return path2.join(tmpDir, name);
+};
+var streamToFile = async (readable, filePath, options) => {
+  await pipeline(readable, fs2.createWriteStream(filePath), { signal: options?.signal });
+};
+var safeUnlink = async (filePath) => {
+  try {
+    await fs2.promises.unlink(filePath);
+  } catch {
+  }
+};
+
 // src/model/openlist/api.ts
+import { logger as logger2 } from "node-karin";
 var openlistApiReadJson = async (res) => {
   try {
     return await res.json();
@@ -441,12 +541,13 @@ var createOpenListApiDirEnsurer = (baseUrl, token, timeoutMs) => {
   return { ensureDir: ensureDir2 };
 };
 var downloadAndUploadByOpenListApiPut = async (params) => {
-  const { sourceUrl, sourceHeaders, targetBaseUrl, targetToken, targetPath, timeoutMs } = params;
+  const { sourceUrl, sourceHeaders, targetBaseUrl, targetToken, targetPath, timeoutMs, expectedSize } = 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");
   await withGlobalTransferLimit(`downloadAndUploadByOpenListApiPut:${targetPath}`, async () => {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let tmpFilePath;
     try {
       let downloadRes;
       try {
@@ -470,16 +571,28 @@ var downloadAndUploadByOpenListApiPut = async (params) => {
       const authToken = String(targetToken ?? "").trim();
       if (authToken) headers.Authorization = authToken;
       const contentType = downloadRes.headers.get("content-type");
-      const contentLength = downloadRes.headers.get("content-length");
+      const contentLength = parseContentLengthHeader(downloadRes.headers.get("content-length"));
       if (contentType) headers["Content-Type"] = contentType;
-      if (contentLength) headers["Content-Length"] = contentLength;
-      const sourceStream = Readable.fromWeb(downloadRes.body);
+      if (contentLength) headers["Content-Length"] = String(contentLength);
+      const sizeForDecision = typeof expectedSize === "number" && Number.isFinite(expectedSize) && expectedSize > 0 ? Math.floor(expectedSize) : contentLength;
+      const spoolToDisk = shouldSpoolToDisk(sizeForDecision);
       let putRes;
       try {
+        let body;
+        if (spoolToDisk) {
+          tmpFilePath = createTransferTempFilePath("openlist-api-put");
+          logger2.info(`[\u4F20\u8F93][\u843D\u76D8] \u68C0\u6D4B\u5230\u5927\u6587\u4EF6\uFF0C\u5C06\u5148\u4E0B\u8F7D\u843D\u76D8\u518D\u4E0A\u4F20(API): ${targetPath}`);
+          await streamToFile(Readable.fromWeb(downloadRes.body), tmpFilePath, { signal: controller.signal });
+          const stat = await fs3.promises.stat(tmpFilePath);
+          headers["Content-Length"] = String(stat.size);
+          body = fs3.createReadStream(tmpFilePath);
+        } else {
+          body = Readable.fromWeb(downloadRes.body);
+        }
         putRes = await fetch(`${apiBaseUrl}/fs/put`, {
           method: "PUT",
           headers,
-          body: sourceStream,
+          body,
           // @ts-expect-error Node fetch streaming body requires duplex
           duplex: "half",
           redirect: "follow",
@@ -498,13 +611,21 @@ var downloadAndUploadByOpenListApiPut = async (params) => {
         const msg = json?.message ? ` - ${json.message}` : "";
         throw new Error(`\u76EE\u6807\u7AEF\u5199\u5165\u5931\u8D25: code=${json.code}${msg}`);
       }
+    } catch (error) {
+      try {
+        controller.abort();
+      } catch {
+      }
+      throw error;
     } finally {
       clearTimeout(timer);
+      if (tmpFilePath) await safeUnlink(tmpFilePath);
     }
   });
 };
 
 // src/model/openlist/webdav.ts
+import fs4 from "fs";
 import { Readable as Readable2 } from "stream";
 import { setTimeout as sleep3 } from "timers/promises";
 
@@ -532,6 +653,7 @@ var createThrottleTransform = (bytesPerSec) => {
 };
 
 // src/model/openlist/webdav.ts
+import { logger as logger3 } from "node-karin";
 var isRetryableWebDavError = (error) => {
   const msg = formatErrorMessage(error);
   return /ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|ECONNREFUSED|UND_ERR|socket hang up/i.test(msg);
@@ -663,6 +785,7 @@ var copyWebDavToWebDav = async (params) => {
   await withGlobalTransferLimit(`copyWebDavToWebDav:${sourcePath}=>${targetPath}`, async () => {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let tmpFilePath;
     try {
       const sourceUrl = `${sourceDavBaseUrl}${encodePathForUrl(sourcePath)}`;
       const targetUrl = `${targetDavBaseUrl}${encodePathForUrl(targetPath)}`;
@@ -688,16 +811,27 @@ var copyWebDavToWebDav = async (params) => {
       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");
+      const contentLength = parseContentLengthHeader(downloadRes.headers.get("content-length"));
       if (contentType) headers["Content-Type"] = contentType;
-      if (contentLength) headers["Content-Length"] = contentLength;
-      const sourceStream = Readable2.fromWeb(downloadRes.body);
+      if (contentLength) headers["Content-Length"] = String(contentLength);
+      const spoolToDisk = shouldSpoolToDisk(contentLength);
       let putRes;
       try {
+        let body;
+        if (spoolToDisk) {
+          tmpFilePath = createTransferTempFilePath("webdav-copy");
+          logger3.info(`[\u4F20\u8F93][\u843D\u76D8] WebDAV\u590D\u5236\u68C0\u6D4B\u5230\u5927\u6587\u4EF6\uFF0C\u5C06\u5148\u4E0B\u8F7D\u843D\u76D8\u518D\u4E0A\u4F20: ${sourcePath} -> ${targetPath}`);
+          await streamToFile(Readable2.fromWeb(downloadRes.body), tmpFilePath, { signal: controller.signal });
+          const stat = await fs4.promises.stat(tmpFilePath);
+          headers["Content-Length"] = String(stat.size);
+          body = fs4.createReadStream(tmpFilePath);
+        } else {
+          body = Readable2.fromWeb(downloadRes.body);
+        }
         putRes = await fetch(targetUrl, {
           method: "PUT",
           headers,
-          body: sourceStream,
+          body,
           // @ts-expect-error Node fetch streaming body requires duplex
           duplex: "half",
           redirect: "follow",
@@ -711,8 +845,15 @@ var copyWebDavToWebDav = async (params) => {
         const body = await fetchTextSafely(putRes);
         throw new Error(`\u76EE\u6807\u7AEF\u5199\u5165\u5931\u8D25: ${putRes.status} ${putRes.statusText}${body ? ` - ${body}` : ""}`);
       }
+    } catch (error) {
+      try {
+        controller.abort();
+      } catch {
+      }
+      throw error;
     } finally {
       clearTimeout(timer);
+      if (tmpFilePath) await safeUnlink(tmpFilePath);
     }
   });
 };
@@ -768,10 +909,11 @@ var createWebDavDirEnsurer = (davBaseUrl, auth, timeoutMs) => {
   return { ensureDir: ensureDir2 };
 };
 var downloadAndUploadByWebDav = async (params) => {
-  const { sourceUrl, sourceHeaders, targetUrl, auth, timeoutMs, rateLimitBytesPerSec } = params;
+  const { sourceUrl, sourceHeaders, targetUrl, auth, timeoutMs, rateLimitBytesPerSec, expectedSize } = params;
   await withGlobalTransferLimit(`downloadAndUploadByWebDav:${targetUrl}`, async () => {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let tmpFilePath;
     try {
       let downloadRes;
       try {
@@ -793,14 +935,26 @@ var downloadAndUploadByWebDav = async (params) => {
         Authorization: auth
       };
       const contentType = downloadRes.headers.get("content-type");
-      const contentLength = downloadRes.headers.get("content-length");
+      const contentLength = parseContentLengthHeader(downloadRes.headers.get("content-length"));
       if (contentType) headers["Content-Type"] = contentType;
-      if (contentLength) headers["Content-Length"] = contentLength;
-      let bodyStream = Readable2.fromWeb(downloadRes.body);
-      const throttle = createThrottleTransform(rateLimitBytesPerSec || 0);
-      if (throttle) bodyStream = bodyStream.pipe(throttle);
+      if (contentLength) headers["Content-Length"] = String(contentLength);
+      const sizeForDecision = typeof expectedSize === "number" && Number.isFinite(expectedSize) && expectedSize > 0 ? Math.floor(expectedSize) : contentLength;
+      const spoolToDisk = shouldSpoolToDisk(sizeForDecision);
       let putRes;
       try {
+        let bodyStream;
+        if (spoolToDisk) {
+          tmpFilePath = createTransferTempFilePath("webdav-download-upload");
+          logger3.info(`[\u4F20\u8F93][\u843D\u76D8] \u68C0\u6D4B\u5230\u5927\u6587\u4EF6\uFF0C\u5C06\u5148\u4E0B\u8F7D\u843D\u76D8\u518D\u4E0A\u4F20: ${targetUrl}`);
+          await streamToFile(Readable2.fromWeb(downloadRes.body), tmpFilePath, { signal: controller.signal });
+          const stat = await fs4.promises.stat(tmpFilePath);
+          headers["Content-Length"] = String(stat.size);
+          bodyStream = fs4.createReadStream(tmpFilePath);
+        } else {
+          bodyStream = Readable2.fromWeb(downloadRes.body);
+        }
+        const throttle = createThrottleTransform(rateLimitBytesPerSec || 0);
+        if (throttle) bodyStream = bodyStream.pipe(throttle);
         putRes = await fetch(targetUrl, {
           method: "PUT",
           headers,
@@ -819,8 +973,15 @@ var downloadAndUploadByWebDav = async (params) => {
         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}` : ""}`);
       }
+    } catch (error) {
+      try {
+        controller.abort();
+      } catch {
+      }
+      throw error;
     } finally {
       clearTimeout(timer);
+      if (tmpFilePath) await safeUnlink(tmpFilePath);
     }
   });
 };
@@ -849,66 +1010,7 @@ var normalizeOpenListBackupTransport = (value, fallback) => {
 };
 var buildTargetPath = (targetRoot, sourcePath) => {
   const rel = String(sourcePath ?? "").replace(/^\/+/, "");
-  return normalizePosixPath(path.posix.join(targetRoot, rel));
-};
-var scanOpenListFiles = async (params) => {
-  const {
-    sourceTransport,
-    sourceBaseUrl,
-    sourceToken,
-    sourceAuth,
-    sourceDavBaseUrl,
-    srcDir,
-    targetRoot,
-    timeoutMs,
-    perPage,
-    scanConcurrency,
-    onProgress
-  } = params;
-  const normalizedSrcDir = normalizePosixPath(String(srcDir ?? "/"));
-  const normalizedTargetRoot = normalizePosixPath(String(targetRoot ?? "/"));
-  const scanConcurrencyMax = Math.max(1, Math.min(200, Math.floor(scanConcurrency) || 20));
-  const files = [];
-  let scannedDirs = 0;
-  const listDir = async (dirPath) => {
-    if (sourceTransport === "webdav") {
-      if (!sourceDavBaseUrl) throw new Error("\u6E90\u7AEF WebDAV \u5730\u5740\u4E0D\u6B63\u786E");
-      return await webdavPropfindListEntries({
-        davBaseUrl: sourceDavBaseUrl,
-        auth: sourceAuth,
-        dirPath,
-        timeoutMs
-      });
-    }
-    return await openlistApiListEntries({
-      baseUrl: sourceBaseUrl,
-      token: sourceToken,
-      dirPath,
-      timeoutMs,
-      perPage
-    });
-  };
-  const reportProgress = () => {
-    if (!onProgress) return;
-    onProgress({ scannedDirs, files: files.length });
-  };
-  let pendingDirs = [normalizedSrcDir];
-  while (pendingDirs.length) {
-    const batch = pendingDirs.splice(0, scanConcurrencyMax);
-    await runWithConcurrency(batch, scanConcurrencyMax, async (dirPath) => {
-      scannedDirs++;
-      const entries = await listDir(dirPath);
-      for (const it of entries) {
-        const sourcePath = normalizePosixPath(path.posix.join(dirPath, it.name));
-        const targetPath = buildTargetPath(normalizedTargetRoot, sourcePath);
-        if (it.isDir) pendingDirs.push(sourcePath);
-        else files.push({ sourcePath, targetPath });
-      }
-      reportProgress();
-    });
-  }
-  reportProgress();
-  return { files, scannedDirs };
+  return normalizePosixPath(path3.posix.join(targetRoot, rel));
 };
 var existsOnTarget = async (params) => {
   const { targetTransport, targetDavBaseUrl, targetAuth, targetBaseUrl, getTargetToken, targetPath, timeoutMs } = params;
@@ -1047,7 +1149,7 @@ var backupOpenListToOpenListCore = async (params) => {
   if (!targetDavBaseUrl) throw new Error("\u76EE\u6807\u7AEF OpenList \u5730\u5740\u4E0D\u6B63\u786E\uFF0C\u8BF7\u68C0\u67E5 openlistBaseUrl");
   const normalizedSrcDir = normalizePosixPath(String(params.srcDir ?? "/"));
   const normalizedTargetBaseDir = normalizePosixPath(String(params.toDir ?? cfg.openlistTargetDir ?? "/"));
-  const targetRoot = params.appendHostDir === false ? normalizedTargetBaseDir : normalizePosixPath(path.posix.join(normalizedTargetBaseDir, safeHostDirName(sourceBaseUrl)));
+  const targetRoot = params.appendHostDir === false ? normalizedTargetBaseDir : normalizePosixPath(path3.posix.join(normalizedTargetBaseDir, safeHostDirName(sourceBaseUrl)));
   const mode = params.mode ?? "incremental";
   const transport = params.transport ?? normalizeOpenListBackupTransport(cfg?.openListBackupTransport, "auto");
   const lockKey = `${sourceBaseUrl} -> ${targetBaseUrl}`;
@@ -1128,46 +1230,12 @@ var backupOpenListToOpenListCore = async (params) => {
     const maxConcurrency = Math.max(1, Math.min(50, Math.floor(params.concurrency || 0) || 3));
     let scannedDirs = 0;
     let scannedFiles = 0;
+    let ok = 0;
+    let skipped = 0;
+    let fail = 0;
     const startAt = Date.now();
-    ticker = setInterval(() => {
-      const elapsed = Math.floor((Date.now() - startAt) / 1e3);
-      enqueueReport(`\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${scannedFiles}`);
-    }, 1e4);
+    const maxFilesLimit = typeof params.maxFiles === "number" && Number.isFinite(params.maxFiles) && params.maxFiles > 0 ? Math.floor(params.maxFiles) : void 0;
     const sourceAuth = hasSourceAuth ? buildOpenListAuthHeader(sourceUsername, sourcePassword) : "";
-    const scanResult = await scanOpenListFiles({
-      sourceTransport,
-      sourceBaseUrl,
-      sourceToken: await getSourceToken(),
-      sourceAuth: sourceAuth || void 0,
-      sourceDavBaseUrl,
-      srcDir: normalizedSrcDir,
-      targetRoot,
-      timeoutMs: listTimeoutMs,
-      perPage: listPerPage,
-      scanConcurrency: scanConcurrencyMax,
-      onProgress: (p) => {
-        scannedDirs = p.scannedDirs;
-        scannedFiles = p.files;
-      }
-    });
-    const files = scanResult.files;
-    if (typeof params.maxFiles === "number" && Number.isFinite(params.maxFiles) && params.maxFiles > 0) {
-      files.splice(Math.floor(params.maxFiles));
-    }
-    if (!files.length) {
-      enqueueReport("\u672A\u53D1\u73B0\u9700\u8981\u5907\u4EFD\u7684\u6587\u4EF6\u3002");
-      return { ok: 0, skipped: 0, fail: 0 };
-    }
-    if (ticker) clearInterval(ticker);
-    ticker = setInterval(() => {
-      const elapsed = Math.floor((Date.now() - startAt) / 1e3);
-      enqueueReport(`\u5907\u4EFD\u8FDB\u884C\u4E2D\uFF08${elapsed}s\uFF09
-\u9636\u6BB5\uFF1A\u590D\u5236
-\u5F85\u5904\u7406\uFF1A${files.length}`);
-    }, 1e4);
     enqueueReport([
       "\u5F00\u59CB\u5907\u4EFD OpenList...",
       `\u6E90\uFF1A${sourceBaseUrl}`,
@@ -1176,14 +1244,13 @@ var backupOpenListToOpenListCore = async (params) => {
       `\u76EE\u6807\u76EE\u5F55\uFF1A${targetRoot}`,
       `\u6A21\u5F0F\uFF1A${mode}`,
       `\u4F20\u8F93\uFF1A${transport}`,
-      `\u6587\u4EF6\u6570\uFF1A${files.length}`
+      `\u626B\u63CF\u5E76\u53D1\uFF1A${scanConcurrencyMax}`,
+      `\u590D\u5236\u5E76\u53D1\uFF1A${maxConcurrency}`,
+      `maxFiles\uFF1A${typeof maxFilesLimit === "number" ? maxFilesLimit : "-"}`
     ].join("\n"));
-    let skipped = 0;
-    let ok = 0;
-    let fail = 0;
     const targetDavBase = targetDavBaseUrl;
     const ensureDirForPath = async (filePath) => {
-      const dirPath = normalizePosixPath(path.posix.dirname(filePath));
+      const dirPath = normalizePosixPath(path3.posix.dirname(filePath));
       targetTransport = await ensureTargetDir({
         dirPath,
         targetTransport,
@@ -1193,50 +1260,109 @@ var backupOpenListToOpenListCore = async (params) => {
         getApiEnsurer: getTargetDirEnsurerApi
       });
     };
-    await runWithConcurrency(files, maxConcurrency, async ({ sourcePath, targetPath }) => {
-      try {
-        if (mode === "incremental") {
-          const exists = await existsOnTarget({
+    const listDirEntries = async (dirPath) => {
+      if (sourceTransport === "webdav") {
+        if (!sourceDavBaseUrl) throw new Error("\u6E90\u7AEF WebDAV \u5730\u5740\u4E0D\u6B63\u786E");
+        return await webdavPropfindListEntries({
+          davBaseUrl: sourceDavBaseUrl,
+          auth: sourceAuth,
+          dirPath,
+          timeoutMs: listTimeoutMs
+        });
+      }
+      return await openlistApiListEntries({
+        baseUrl: sourceBaseUrl,
+        token: await getSourceToken(),
+        dirPath,
+        timeoutMs: listTimeoutMs,
+        perPage: listPerPage
+      });
+    };
+    const executing = /* @__PURE__ */ new Set();
+    const launchCopy = (file) => {
+      const task = (async () => {
+        const { sourcePath, targetPath } = file;
+        try {
+          if (mode === "incremental") {
+            const exists = await existsOnTarget({
+              targetTransport,
+              targetDavBaseUrl: targetDavBase,
+              targetAuth,
+              targetBaseUrl,
+              getTargetToken,
+              targetPath,
+              timeoutMs: listTimeoutMs
+            });
+            if (exists) {
+              skipped++;
+              return;
+            }
+          }
+          await ensureDirForPath(targetPath);
+          await copyOpenListFile({
+            sourceTransport,
             targetTransport,
+            sourceBaseUrl,
+            sourceDavBaseUrl,
+            sourceAuth,
+            targetBaseUrl,
             targetDavBaseUrl: targetDavBase,
             targetAuth,
-            targetBaseUrl,
-            getTargetToken,
+            sourcePath,
             targetPath,
-            timeoutMs: listTimeoutMs
+            getSourceToken,
+            getTargetToken,
+            timeoutMs
           });
-          if (exists) {
-            skipped++;
-            return;
+          ok++;
+        } catch (error) {
+          fail++;
+          logger4.error(error);
+          if (allowAutoFallback) {
+            const msg = formatErrorMessage(error);
+            if (targetTransport === "webdav" && /401|403|MKCOL|PUT/i.test(msg)) targetTransport = "api";
+            else if (targetTransport === "api" && /fs\/put|fs\/mkdir|code=/i.test(msg)) targetTransport = "webdav";
           }
         }
-        await ensureDirForPath(targetPath);
-        await copyOpenListFile({
-          sourceTransport,
-          targetTransport,
-          sourceBaseUrl,
-          sourceDavBaseUrl,
-          sourceAuth,
-          targetBaseUrl,
-          targetDavBaseUrl: targetDavBase,
-          targetAuth,
-          sourcePath,
-          targetPath,
-          getSourceToken,
-          getTargetToken,
-          timeoutMs
-        });
-        ok++;
-      } catch (error) {
-        fail++;
-        logger2.error(error);
-        if (allowAutoFallback) {
-          const msg = formatErrorMessage(error);
-          if (targetTransport === "webdav" && /401|403|MKCOL|PUT/i.test(msg)) targetTransport = "api";
-          else if (targetTransport === "api" && /fs\/put|fs\/mkdir|code=/i.test(msg)) targetTransport = "webdav";
+      })();
+      executing.add(task);
+      task.finally(() => executing.delete(task));
+      return task;
+    };
+    ticker = setInterval(() => {
+      const elapsed = Math.floor((Date.now() - startAt) / 1e3);
+      enqueueReport([
+        `\u5907\u4EFD\u8FDB\u884C\u4E2D\uFF08${elapsed}s\uFF09`,
+        `\u5DF2\u626B\u63CF\u76EE\u5F55\uFF1A${scannedDirs}`,
+        `\u5DF2\u53D1\u73B0\u6587\u4EF6\uFF1A${scannedFiles}${typeof maxFilesLimit === "number" ? `/${maxFilesLimit}` : ""}`,
+        `\u8FDB\u5EA6\uFF1Aok=${ok} skip=${skipped} fail=${fail}`,
+        `\u5E76\u53D1\uFF1AinFlight=${executing.size}/${maxConcurrency}`
+      ].join("\n"));
+    }, 1e4);
+    let pendingDirs = [normalizedSrcDir];
+    while (pendingDirs.length) {
+      const dirPath = pendingDirs.pop();
+      scannedDirs++;
+      const entries = await listDirEntries(dirPath);
+      for (const it of entries) {
+        const sourcePath = normalizePosixPath(path3.posix.join(dirPath, it.name));
+        const targetPath = buildTargetPath(targetRoot, sourcePath);
+        if (it.isDir) {
+          pendingDirs.push(sourcePath);
+          continue;
+        }
+        scannedFiles++;
+        if (typeof maxFilesLimit === "number" && scannedFiles > maxFilesLimit) {
+          pendingDirs = [];
+          break;
+        }
+        launchCopy({ sourcePath, targetPath });
+        if (executing.size >= maxConcurrency) {
+          await Promise.race(executing);
         }
       }
-    });
+    }
+    await Promise.all(executing);
     enqueueReport(`\u5907\u4EFD\u5B8C\u6210\uFF1A\u6210\u529F ${ok}\uFF0C\u8DF3\u8FC7 ${skipped}\uFF0C\u5931\u8D25 ${fail}`);
     return { ok, skipped, fail };
   } finally {
@@ -1245,24 +1371,6 @@ var backupOpenListToOpenListCore = async (params) => {
   }
 };
 
-// src/model/shared/fsJson.ts
-import fs from "fs";
-import path2 from "path";
-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(path2.dirname(filePath));
-  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf8");
-};
-
 export {
   buildOpenListDavBaseUrl,
   buildOpenListAuthHeader,
@@ -1270,13 +1378,13 @@ export {
   safePathSegment,
   encodePathForUrl,
   formatErrorMessage,
+  ensureDir,
+  readJsonSafe,
+  writeJsonSafe,
   webdavPropfindListNames,
   createWebDavDirEnsurer,
   downloadAndUploadByWebDav,
   runWithConcurrency,
   runWithAdaptiveConcurrency,
-  backupOpenListToOpenListCore,
-  ensureDir,
-  readJsonSafe,
-  writeJsonSafe
+  backupOpenListToOpenListCore
 };

package/lib/{chunk-I2I6ZPJU.js → chunk-P5FZDWLZ.js}

@@ -1,11 +1,11 @@
 import {
   syncGroupFilesToOpenListCore
-} from "./chunk-BWVJMEKK.js";
+} from "./chunk-R4MRR5TI.js";
 import {
   normalizePosixPath,
   readJsonSafe,
   writeJsonSafe
-} from "./chunk-YVFRUAZO.js";
+} from "./chunk-GDVU2T6R.js";
 import {
   config
 } from "./chunk-DA4U55JC.js";

package/lib/{chunk-BWVJMEKK.js → chunk-R4MRR5TI.js}

@@ -2,7 +2,7 @@ import {
   readGroupSyncState,
   withGroupSyncLock,
   writeGroupSyncState
-} from "./chunk-5QW7XYQX.js";
+} from "./chunk-DDV3OZXB.js";
 import {
   buildOpenListAuthHeader,
   buildOpenListDavBaseUrl,
@@ -16,7 +16,7 @@ import {
   runWithConcurrency,
   safePathSegment,
   webdavPropfindListNames
-} from "./chunk-YVFRUAZO.js";
+} from "./chunk-GDVU2T6R.js";
 import {
   config,
   time
@@ -508,13 +508,14 @@ var syncGroupFilesToOpenListCore = async (params) => {
     const shouldRefreshUrl = (message) => {
       return /403|URL已过期|url已过期|url可能已失效|需要重新获取|下载超时/.test(message);
     };
-    const transferOne = async (sourceUrl, targetUrl) => {
+    const transferOne = async (sourceUrl, targetUrl, expectedSize) => {
       await downloadAndUploadByWebDav({
         sourceUrl,
         targetUrl,
         auth,
         timeoutMs: transferTimeoutMs,
-        rateLimitBytesPerSec: effectiveRateLimitBytesPerSec || void 0
+        rateLimitBytesPerSec: effectiveRateLimitBytesPerSec || void 0,
+        expectedSize
       });
     };
     report && await report("\u5F00\u59CB\u4E0B\u8F7D\u5E76\u4E0A\u4F20\u5230 OpenList\uFF0C\u8BF7\u7A0D\u5019..");
@@ -532,7 +533,7 @@ var syncGroupFilesToOpenListCore = async (params) => {
           await dirEnsurer.ensureDir(remoteDir);
           const currentUrl = item.url;
           if (!currentUrl) throw new Error("\u7F3A\u5C11\u4E0B\u8F7D URL");
-          await transferOne(currentUrl, targetUrl);
+          await transferOne(currentUrl, targetUrl, item.size);
           okCount++;
           succeeded = true;
           lastError = void 0;
@@ -817,7 +818,8 @@ var handleGroupFileUploadedAutoBackup = (e) => {
                 targetUrl,
                 auth,
                 timeoutMs: transferTimeoutMs,
-                rateLimitBytesPerSec: effectiveRateLimitBytesPerSec || void 0
+                rateLimitBytesPerSec: effectiveRateLimitBytesPerSec || void 0,
+                expectedSize: size
               });
               break;
             } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "karin-plugin-qgroup-file2openlist",
-  "version": "0.0.26",
+  "version": "0.0.27",
   "author": "429",
   "type": "module",
   "description": "karin plugin for QGroupFile backup",