🐛 修复云同步问题 (#1133)

CodFrm · Copilot · Copilot · web-flow · commit a9383d2012eb · 2026-01-06T15:01:13.000+08:00
* 优化同步逻辑 * 文件系统操作限制速率 * 修复同步状态同步问题 * 修复排序顺序问题 #964 * Update packages/filesystem/limiter.ts Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update packages/filesystem/limiter.ts Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update packages/filesystem/factory.ts Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * 对文件系统操作应用速率限制 Apply rate limiting to filesystem operations (#1134) * Initial plan * Apply rate limiting to open, openDir and create operations Co-authored-by: CodFrm <22783163+CodFrm@users.noreply.github.com> * Merge fix/cloud-sync and apply rate limiting to open() method Co-authored-by: CodFrm <22783163+CodFrm@users.noreply.github.com> --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: CodFrm <22783163+CodFrm@users.noreply.github.com> --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Co-authored-by: Copilot <198982749+Copilot@users.noreply.github.com>
diff --git a/packages/filesystem/factory.ts b/packages/filesystem/factory.ts
@@ -6,6 +6,7 @@ import DropboxFileSystem from "./dropbox/dropbox";
 import WebDAVFileSystem from "./webdav/webdav";
 import ZipFileSystem from "./zip/zip";
 import { t } from "@App/locales/locales";
+import LimiterFileSystem from "./limiter";
 
 export type FileSystemType = "zip" | "webdav" | "baidu-netdsik" | "onedrive" | "googledrive" | "dropbox";
 
@@ -42,7 +43,8 @@ export default class FileSystemFactory {
       default:
         throw new Error("not found filesystem");
     }
-    return fs.verify().then(() => fs);
+    const limitedFs = new LimiterFileSystem(fs);
+    return limitedFs.verify().then(() => limitedFs);
   }
 
   static params(): { [key: string]: FileSystemParams } {
diff --git a/packages/filesystem/limiter.ts b/packages/filesystem/limiter.ts
@@ -0,0 +1,102 @@
+import type FileSystem from "./filesystem";
+import type { File, FileReader, FileWriter } from "./filesystem";
+
+/**
+ * 速率限制器
+ * 控制并发操作数量，防止过多并发请求
+ */
+export class RateLimiter {
+  private queue: Array<() => void> = [];
+
+  private running = 0;
+
+  private maxConcurrent: number;
+
+  constructor(maxConcurrent = 5) {
+    this.maxConcurrent = maxConcurrent;
+  }
+
+  /**
+   * 执行限速操作
+   * @param fn 要执行的操作函数
+   * @returns 操作结果
+   */
+  async execute<T>(fn: () => Promise<T>): Promise<T> {
+    // 如果当前运行的操作数已达到上限，则等待
+    while (this.running >= this.maxConcurrent) {
+      await new Promise<void>((resolve) => {
+        this.queue.push(resolve);
+      });
+    }
+
+    this.running++;
+    try {
+      return await fn();
+    } finally {
+      this.running--;
+      // 执行完成后，从队列中取出下一个等待的操作
+      const next = this.queue.shift();
+      if (next) {
+        next();
+      }
+    }
+  }
+}
+
+// 文件系统限速器，防止并发请求过多达到服务器限制
+// 也防止上传/下载带宽占用过多超时导致失败/数据不全的问题
+export default class LimiterFileSystem implements FileSystem {
+  private fs: FileSystem;
+
+  private limiter: RateLimiter;
+
+  constructor(fs: FileSystem, limiter?: RateLimiter) {
+    this.fs = fs;
+    this.limiter = limiter || new RateLimiter();
+  }
+
+  verify(): Promise<void> {
+    return this.limiter.execute(() => this.fs.verify());
+  }
+
+  async open(file: File): Promise<FileReader> {
+    return this.limiter.execute(async () => {
+      const reader = await this.fs.open(file);
+      return {
+        read: (type) => this.limiter.execute(() => reader.read(type)),
+      };
+    });
+  }
+
+  async openDir(path: string): Promise<FileSystem> {
+    return this.limiter.execute(async () => {
+      const fs = await this.fs.openDir(path);
+      return new LimiterFileSystem(fs, this.limiter);
+    });
+  }
+
+  async create(path: string): Promise<FileWriter> {
+    return this.limiter.execute(async () => {
+      const writer = await this.fs.create(path);
+      return {
+        write: (content) => this.limiter.execute(() => writer.write(content)),
+      };
+    });
+  }
+
+  createDir(dir: string): Promise<void> {
+    return this.limiter.execute(() => this.fs.createDir(dir));
+  }
+
+  delete(path: string): Promise<void> {
+    return this.limiter.execute(() => this.fs.delete(path));
+  }
+
+  list(): Promise<File[]> {
+    return this.limiter.execute(() => this.fs.list());
+  }
+
+  getDirUrl(): Promise<string> {
+    return this.limiter.execute(() => this.fs.getDirUrl());
+  }
+}
diff --git a/src/app/service/service_worker/synchronize.ts b/src/app/service/service_worker/synchronize.ts
@@ -1,7 +1,7 @@
 import LoggerCore from "@App/app/logger/core";
 import Logger from "@App/app/logger/logger";
 import type { Resource } from "@App/app/repo/resource";
-import { type Script, SCRIPT_STATUS_ENABLE, type ScriptDAO } from "@App/app/repo/scripts";
+import { type Script, SCRIPT_STATUS_DISABLE, SCRIPT_STATUS_ENABLE, type ScriptDAO } from "@App/app/repo/scripts";
 import BackupExport from "@App/pkg/backup/export";
 import type { BackupData, ResourceBackup, ScriptBackupData, ScriptOptions, ValueStorage } from "@App/pkg/backup/struct";
 import type { File } from "@Packages/filesystem/filesystem";
@@ -46,23 +46,25 @@ type ScriptcatSync = {
   version: string; // 脚本猫版本
   status: {
     scripts: {
-      [key: string]: {
-        enable: boolean;
-        sort: number;
-        updatetime: number; // 更新时间
-      };
+      [key: string]: ScriptcatSyncStatus | undefined;
     };
   };
 };
 
+type ScriptcatSyncStatus = {
+  enable: boolean;
+  sort: number;
+  updatetime: number; // 更新时间
+};
+
 type PushScriptParam = TInstallScriptParams;
 
 export class SynchronizeService {
   logger: Logger;
 
   scriptCodeDAO = this.scriptDAO.scriptCodeDAO;
 
-  storage: ChromeStorage = new ChromeStorage("sync", true);
+  storage: ChromeStorage = new ChromeStorage("sync", false);
 
   constructor(
     private msgSender: MessageSend,
@@ -340,13 +342,6 @@ export class SynchronizeService {
         [key: string]: string;
       }) || {};
 
-    let scriptcatSync = {
-      version: ExtVersion,
-      status: {
-        scripts: {},
-      },
-    } as ScriptcatSync;
-
     for (const file of list) {
       if (file.name.endsWith(".user.js")) {
         const uuid = file.name.substring(0, file.name.length - 8);
@@ -374,8 +369,25 @@ export class SynchronizeService {
     scriptList.forEach((script) => {
       scriptMap.set(script.uuid, script);
     });
+
+    // 判断文件系统是否有脚本猫同步文件
+    const file = list.find((file) => file.name === "scriptcat-sync.json");
+    const scriptcatSync = {
+      version: ExtVersion,
+      status: {
+        scripts: {},
+      },
+    } as ScriptcatSync;
+    let cloudStatus: ScriptcatSync["status"]["scripts"] = {};
+    if (file) {
+      // 如果有,则读取文件内容
+      const cloudScriptCatSync = JSON.parse(await fs.open(file).then((f) => f.read("string"))) as ScriptcatSync;
+      cloudStatus = cloudScriptCatSync.status.scripts;
+    }
+
     // 对比脚本列表和文件列表,进行同步
     const result: Promise<void>[] = [];
+    const updateScript: Map<string, boolean> = new Map();
     uuidMap.forEach((file, uuid) => {
       const script = scriptMap.get(uuid);
       if (script) {
@@ -421,14 +433,16 @@ export class SynchronizeService {
           result.push(this.pushScript(fs, script));
         } else {
           // 如果脚本更新时间小于文件更新时间,则更新脚本
-          result.push(this.pullScript(fs, file as SyncFiles, script));
+          updateScript.set(uuid, true);
+          result.push(this.pullScript(fs, file as SyncFiles, cloudStatus[uuid], script));
         }
         scriptMap.delete(uuid);
         return;
       }
       // 如果脚本不存在,且文件存在,则安装脚本
       if (file.script) {
-        result.push(this.pullScript(fs, file as SyncFiles));
+        updateScript.set(uuid, true);
+        result.push(this.pullScript(fs, file as SyncFiles, cloudStatus[uuid]));
       }
     });
     // 上传剩下的脚本
@@ -439,51 +453,53 @@ export class SynchronizeService {
     await Promise.allSettled(result);
     // 同步状态
     if (syncConfig.syncStatus) {
-      // 判断文件系统是否有脚本猫同步文件
-      const file = list.find((file) => file.name === "scriptcat-sync.json");
-      if (file) {
-        // 如果有,则读取文件内容
-        scriptcatSync = JSON.parse(await fs.open(file).then((f) => f.read("string"))) as ScriptcatSync;
-      }
       const scriptlist = await this.scriptDAO.all();
-      const status = scriptcatSync.status.scripts;
-      scriptlist.forEach(async (script) => {
-        // 判断云端状态是否与本地状态一致
-        if (!status[script.uuid]) {
-          status[script.uuid] = {
-            enable: script.status === SCRIPT_STATUS_ENABLE,
-            sort: script.sort,
-            updatetime: script.updatetime || script.createtime,
-          };
-        } else {
-          // 判断时间
-          if (script.updatetime) {
+      await Promise.allSettled(
+        scriptlist.map(async (script) => {
+          // 判断云端状态是否与本地状态一致
+          const status = cloudStatus[script.uuid];
+          const updatetime = script.updatetime || script.createtime;
+          if (!status) {
+            scriptcatSync.status.scripts[script.uuid] = {
+              enable: script.status === SCRIPT_STATUS_ENABLE,
+              sort: script.sort,
+              updatetime: updatetime,
+            };
+          } else {
+            if (updateScript.has(script.uuid)) {
+              // 脚本已经更新过了,跳过状态同步
+              scriptcatSync.status.scripts[script.uuid] = status;
+              return;
+            }
+            // 判断时间
             // 如果云端状态的更新时间小于本地状态的更新时间,则更新云端状态
-            if (status[script.uuid].updatetime < script.updatetime) {
-              status[script.uuid].enable = script.status === SCRIPT_STATUS_ENABLE;
-              status[script.uuid].sort = script.sort;
-              status[script.uuid].updatetime = script.updatetime;
+            if (status.updatetime < updatetime) {
+              scriptcatSync.status.scripts[script.uuid] = {
+                enable: script.status === SCRIPT_STATUS_ENABLE,
+                sort: script.sort,
+                updatetime: updatetime,
+              };
               return;
             }
+            // 否则采用云端状态
+            scriptcatSync.status.scripts[script.uuid] = status;
+            // 脚本顺序
+            if (status.sort !== script.sort) {
+              await this.scriptDAO.update(script.uuid, {
+                sort: status.sort,
+              });
+            }
+            // 脚本状态
+            if (status.enable !== (script.status === SCRIPT_STATUS_ENABLE)) {
+              // 开启脚本
+              await this.script.enableScript({
+                uuid: script.uuid,
+                enable: status.enable,
+              });
+            }
           }
-          // 否则采用云端状态
-          // 脚本顺序
-          if (status[script.uuid].sort !== script.sort) {
-            await this.scriptDAO.update(script.uuid, {
-              sort: status[script.uuid].sort,
-              updatetime: Date.now(),
-            });
-          }
-          // 脚本状态
-          if (status[script.uuid].enable !== (script.status === SCRIPT_STATUS_ENABLE)) {
-            // 开启脚本
-            this.script.enableScript({
-              uuid: script.uuid,
-              enable: status[script.uuid].enable,
-            });
-          }
-        }
-      });
+        })
+      );
       // 保存脚本猫同步状态
       const syncFile = await fs.create("scriptcat-sync.json");
       await syncFile.write(JSON.stringify(scriptcatSync, null, 2));
@@ -568,7 +584,7 @@ export class SynchronizeService {
     return;
   }
 
-  async pullScript(fs: FileSystem, file: SyncFiles, existingScript?: Script) {
+  async pullScript(fs: FileSystem, file: SyncFiles, status: ScriptcatSyncStatus | undefined, existingScript?: Script) {
     const logger = this.logger.with({
       uuid: existingScript?.uuid || "",
       name: existingScript?.name || "",
@@ -588,6 +604,19 @@ export class SynchronizeService {
         existingScript?.uuid || metaObj.uuid
       );
       script.origin = script.origin || metaObj.origin;
+      if (status) {
+        if (existingScript) {
+          if (!existingScript.updatetime || status.updatetime > existingScript.updatetime) {
+            // 如果云端状态的更新时间大于本地状态的更新时间,则采用云端状态
+            script.sort = status.sort;
+            script.status = status.enable ? SCRIPT_STATUS_ENABLE : SCRIPT_STATUS_DISABLE;
+          }
+        } else {
+          // 新安装的脚本采用云端状态
+          script.sort = status.sort;
+          script.status = status.enable ? SCRIPT_STATUS_ENABLE : SCRIPT_STATUS_DISABLE;
+        }
+      }
       this.script.installScript({
         script,
         code,
@@ -597,7 +626,6 @@ export class SynchronizeService {
     } catch (e) {
       logger.error("pull script error", Logger.E(e));
     }
-    return;
   }
 
   cloudSyncConfigChange(value: CloudSyncConfig) {

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@ import DropboxFileSystem from "./dropbox/dropbox";`
`6`	`6`	`import WebDAVFileSystem from "./webdav/webdav";`
`7`	`7`	`import ZipFileSystem from "./zip/zip";`
`8`	`8`	`import { t } from "@App/locales/locales";`
	`9`	`+import LimiterFileSystem from "./limiter";`
`9`	`10`
`10`	`11`	`export type FileSystemType = "zip" \| "webdav" \| "baidu-netdsik" \| "onedrive" \| "googledrive" \| "dropbox";`
`11`	`12`
`@@ -42,7 +43,8 @@ export default class FileSystemFactory {`
`42`	`43`	`default:`
`43`	`44`	`throw new Error("not found filesystem");`
`44`	`45`	`}`
`45`		`- return fs.verify().then(() => fs);`
	`46`	`+ const limitedFs = new LimiterFileSystem(fs);`
	`47`	`+ return limitedFs.verify().then(() => limitedFs);`
`46`	`48`	`}`
`47`	`49`
`48`	`50`	`static params(): { [key: string]: FileSystemParams } {`