karin-plugin-qgroup-file2openlist 0.0.26 → 0.0.28

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-ZXZMBJN3.js";
+import "../chunk-AAKFRFSO.js";
 import {
   backupOpenListToOpenListCore,
   formatErrorMessage
-} from "../chunk-YVFRUAZO.js";
+} from "../chunk-HSFFULJR.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-ZXZMBJN3.js";
+import "../chunk-AAKFRFSO.js";
 import {
   formatErrorMessage,
   normalizePosixPath
-} from "../chunk-YVFRUAZO.js";
+} from "../chunk-HSFFULJR.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-H2TAMQ7I.js";
+import "../chunk-ZXZMBJN3.js";
+import "../chunk-AAKFRFSO.js";
+import "../chunk-HSFFULJR.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-GAVQ23XT.js";
 import {
   buildActionCard,
   replyImages
@@ -20,7 +20,7 @@ import {
   normalizePosixPath,
   readJsonSafe,
   writeJsonSafe
-} from "../chunk-YVFRUAZO.js";
+} from "../chunk-HSFFULJR.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-AAKFRFSO.js";
 import {
   backupOpenListToOpenListCore,
   formatErrorMessage,
   normalizePosixPath,
   readJsonSafe,
   writeJsonSafe
-} from "../chunk-YVFRUAZO.js";
+} from "../chunk-HSFFULJR.js";
 import "../chunk-DA4U55JC.js";
 import {
   dir

package/lib/apps/scheduler.js

@@ -1,12 +1,12 @@
 import {
   runNightlyOpltBackup
-} from "../chunk-WQFR5LF3.js";
+} from "../chunk-GAVQ23XT.js";
 import {
   runNightlyGroupBackup
-} from "../chunk-I2I6ZPJU.js";
-import "../chunk-BWVJMEKK.js";
-import "../chunk-5QW7XYQX.js";
-import "../chunk-YVFRUAZO.js";
+} from "../chunk-H2TAMQ7I.js";
+import "../chunk-ZXZMBJN3.js";
+import "../chunk-AAKFRFSO.js";
+import "../chunk-HSFFULJR.js";
 import {
   config
 } from "../chunk-DA4U55JC.js";

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

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

package/lib/{chunk-WQFR5LF3.js → chunk-GAVQ23XT.js}

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

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

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

package/lib/{chunk-YVFRUAZO.js → chunk-HSFFULJR.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 } = {}) => {
@@ -40,18 +43,84 @@ var formatErrorMessage = (error) => {
 var isAbortError = (error) => {
   return Boolean(error && typeof error === "object" && "name" in error && error.name === "AbortError");
 };
+var drainResponseBody = async (res) => {
+  try {
+    const body = res.body;
+    if (!body) return;
+    const reader = body.getReader();
+    while (true) {
+      const { done } = await reader.read();
+      if (done) break;
+    }
+  } catch {
+    try {
+      await res.body?.cancel();
+    } catch {
+    }
+  }
+};
 var fetchTextSafely = async (res, maxLen = 500) => {
   try {
-    const text = await res.text();
-    return text.slice(0, maxLen);
+    const maxBytes = Math.max(0, Math.floor(maxLen) || 0);
+    if (!maxBytes) {
+      await res.body?.cancel();
+      return "";
+    }
+    const body = res.body;
+    if (!body) return "";
+    const reader = body.getReader();
+    const chunks = [];
+    let total = 0;
+    while (total < maxBytes) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      if (!value || value.byteLength <= 0) continue;
+      const remaining = maxBytes - total;
+      if (value.byteLength <= remaining) {
+        chunks.push(value);
+        total += value.byteLength;
+        continue;
+      }
+      chunks.push(value.slice(0, remaining));
+      total += remaining;
+      break;
+    }
+    try {
+      await reader.cancel();
+    } catch {
+    }
+    if (!chunks.length) return "";
+    return Buffer.concat(chunks.map((c) => Buffer.from(c))).toString("utf8");
   } catch {
+    try {
+      await res.body?.cancel();
+    } catch {
+    }
     return "";
   }
 };
 
-// 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 +245,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 +317,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 +589,14 @@ 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;
+    let uploadFileStream;
     try {
       let downloadRes;
       try {
@@ -470,16 +620,29 @@ 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);
+          uploadFileStream = fs3.createReadStream(tmpFilePath);
+          body = uploadFileStream;
+        } 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 +661,30 @@ 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 (uploadFileStream) {
+        await new Promise((resolve) => {
+          try {
+            uploadFileStream.close(() => resolve());
+          } catch {
+            resolve();
+          }
+        });
+      }
+      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,54 +712,12 @@ 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);
 };
 var webdavMkcolOk = (status) => status === 201 || status === 405;
-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 webdavPropfindListEntries = async (params) => {
   const { davBaseUrl, auth, dirPath, timeoutMs } = params;
   const controller = new AbortController();
@@ -607,7 +745,13 @@ var webdavPropfindListEntries = async (params) => {
       redirect: "follow",
       signal: controller.signal
     });
-    if (!res.ok) return [];
+    if (!res.ok) {
+      try {
+        await res.body?.cancel();
+      } catch {
+      }
+      return [];
+    }
     const text = await res.text();
     if (!text) return [];
     const out = [];
@@ -663,6 +807,8 @@ var copyWebDavToWebDav = async (params) => {
   await withGlobalTransferLimit(`copyWebDavToWebDav:${sourcePath}=>${targetPath}`, async () => {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let tmpFilePath;
+    let uploadFileStream;
     try {
       const sourceUrl = `${sourceDavBaseUrl}${encodePathForUrl(sourcePath)}`;
       const targetUrl = `${targetDavBaseUrl}${encodePathForUrl(targetPath)}`;
@@ -688,16 +834,28 @@ 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);
+          uploadFileStream = fs4.createReadStream(tmpFilePath);
+          body = uploadFileStream;
+        } 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 +869,25 @@ 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}` : ""}`);
       }
+      await drainResponseBody(putRes);
+    } catch (error) {
+      try {
+        controller.abort();
+      } catch {
+      }
+      throw error;
     } finally {
       clearTimeout(timer);
+      if (uploadFileStream) {
+        await new Promise((resolve) => {
+          try {
+            uploadFileStream.close(() => resolve());
+          } catch {
+            resolve();
+          }
+        });
+      }
+      if (tmpFilePath) await safeUnlink(tmpFilePath);
     }
   });
 };
@@ -752,6 +927,7 @@ var createWebDavDirEnsurer = (davBaseUrl, auth, timeoutMs) => {
             const body = await fetchTextSafely(res);
             throw new Error(`MKCOL \u5931\u8D25: ${current} -> ${res.status} ${res.statusText}${body ? ` - ${body}` : ""}`);
           }
+          await drainResponseBody(res);
         } finally {
           clearTimeout(timer);
         }
@@ -768,10 +944,12 @@ 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;
+    let uploadFileStream;
     try {
       let downloadRes;
       try {
@@ -793,14 +971,27 @@ 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);
+          uploadFileStream = fs4.createReadStream(tmpFilePath);
+          bodyStream = uploadFileStream;
+        } 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 +1010,25 @@ 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}` : ""}`);
       }
+      await drainResponseBody(putRes);
+    } catch (error) {
+      try {
+        controller.abort();
+      } catch {
+      }
+      throw error;
     } finally {
       clearTimeout(timer);
+      if (uploadFileStream) {
+        await new Promise((resolve) => {
+          try {
+            uploadFileStream.close(() => resolve());
+          } catch {
+            resolve();
+          }
+        });
+      }
+      if (tmpFilePath) await safeUnlink(tmpFilePath);
     }
   });
 };
@@ -849,66 +1057,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 +1196,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 +1277,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 +1291,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 +1307,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 +1418,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 +1425,13 @@ export {
   safePathSegment,
   encodePathForUrl,
   formatErrorMessage,
-  webdavPropfindListNames,
+  ensureDir,
+  readJsonSafe,
+  writeJsonSafe,
+  webdavHeadExists,
   createWebDavDirEnsurer,
   downloadAndUploadByWebDav,
   runWithConcurrency,
   runWithAdaptiveConcurrency,
-  backupOpenListToOpenListCore,
-  ensureDir,
-  readJsonSafe,
-  writeJsonSafe
+  backupOpenListToOpenListCore
 };

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

@@ -2,7 +2,7 @@ import {
   readGroupSyncState,
   withGroupSyncLock,
   writeGroupSyncState
-} from "./chunk-5QW7XYQX.js";
+} from "./chunk-AAKFRFSO.js";
 import {
   buildOpenListAuthHeader,
   buildOpenListDavBaseUrl,
@@ -15,8 +15,8 @@ import {
   runWithAdaptiveConcurrency,
   runWithConcurrency,
   safePathSegment,
-  webdavPropfindListNames
-} from "./chunk-YVFRUAZO.js";
+  webdavHeadExists
+} from "./chunk-HSFFULJR.js";
 import {
   config,
   time
@@ -461,24 +461,18 @@ var syncGroupFilesToOpenListCore = async (params) => {
       return !ok;
     }) : candidates;
     if (mode === "incremental" && needSync.length) {
-      const dirs = Array.from(new Set(
-        needSync.map(({ remotePath }) => normalizePosixPath(path2.posix.dirname(remotePath)))
-      ));
-      const namesByDir = /* @__PURE__ */ new Map();
-      await runWithConcurrency(dirs, 3, async (dirPath) => {
-        const names = await webdavPropfindListNames({
+      const existsResults = new Array(needSync.length).fill(false);
+      const existsConcurrency = 10;
+      await runWithConcurrency(needSync, existsConcurrency, async ({ remotePath }, index) => {
+        existsResults[index] = await webdavHeadExists({
           davBaseUrl,
           auth,
-          dirPath,
+          filePath: remotePath,
           timeoutMs: webdavTimeoutMs
         });
-        namesByDir.set(dirPath, names);
       });
-      needSync = needSync.filter(({ remotePath }) => {
-        const dirPath = normalizePosixPath(path2.posix.dirname(remotePath));
-        const base = path2.posix.basename(remotePath);
-        const names = namesByDir.get(dirPath);
-        if (names && names.has(base)) {
+      needSync = needSync.filter((_it, index) => {
+        if (existsResults[index]) {
           skipped++;
           return false;
         }
@@ -508,13 +502,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 +527,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;
@@ -686,13 +681,15 @@ var handleGroupFileUploadedAutoBackup = (e) => {
         const normalized = direct ? normalizeGroupFileRelativePath(direct) : "";
         if (normalized) item.path = normalized;
         const bot = e?.bot;
-        if (bot && !item.path.includes("/")) {
+        const resolvePathEnabled = typeof targetCfg?.uploadBackupResolvePath === "boolean" ? Boolean(targetCfg.uploadBackupResolvePath) : true;
+        const resolvePathMaxFolders = typeof targetCfg?.uploadBackupResolvePathMaxFolders === "number" ? Math.max(1, Math.floor(Number(targetCfg.uploadBackupResolvePathMaxFolders)) || 1) : 4e3;
+        if (resolvePathEnabled && bot && !item.path.includes("/")) {
           try {
             const found = await locateGroupFileByIdWithRetry(bot, groupId, fid, {
               retries: 3,
               delayMs: 1200,
               timeoutMs: 15e3,
-              maxFolders: 4e3,
+              maxFolders: resolvePathMaxFolders,
               expectedName: name,
               expectedSize: size
             });
@@ -704,6 +701,8 @@ var handleGroupFileUploadedAutoBackup = (e) => {
           } catch (error) {
             logger3.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)}`);
           }
+        } else if (!resolvePathEnabled && bot && !item.path.includes("/")) {
+          logger3.debug(`[\u7FA4\u4E0A\u4F20\u5907\u4EFD][${groupId}] uploadBackupResolvePath=false\uFF0C\u5DF2\u8DF3\u8FC7\u7FA4\u6587\u4EF6\u5939\u8DEF\u5F84\u89E3\u6790\uFF1A${name}`);
         }
       }
       const resolveUrl = async () => {
@@ -817,7 +816,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.28",
   "author": "429",
   "type": "module",
   "description": "karin plugin for QGroupFile backup",