code update

Author: cyfung1031

packages/filesystem/baidu/baidu.test.ts

@@ -33,15 +33,57 @@ describe("BaiduFileSystem", () => {
     expect(updateDynamicRulesMock).not.toHaveBeenCalled();
   });
 
-  it("create should reject conditional write options as unsupported", async () => {
+  it("create should reject expectedVersion as unsupported", async () => {
     const fs = new BaiduFileSystem("/apps", "token");
 
-    await expect(fs.create("test.txt", { expectedDigest: "md5" })).rejects.toMatchObject({
+    await expect(fs.create("test.txt", { expectedVersion: "version" })).rejects.toMatchObject({
       provider: "baidu",
       unsupported: true,
     });
   });
 
+  it("writer should reject createOnly when target already exists", async () => {
+    const fs = new BaiduFileSystem("/apps", "token");
+    vi.spyOn(fs, "list").mockResolvedValue([
+      {
+        name: "test.txt",
+        path: "/apps",
+        size: 1,
+        digest: "md5",
+        createtime: 1,
+        updatetime: 1,
+      },
+    ]);
+
+    const writer = await fs.create("test.txt", { createOnly: true });
+
+    await expect(writer.write("content")).rejects.toMatchObject({
+      provider: "baidu",
+      conflict: true,
+    });
+  });
+
+  it("writer should reject expectedDigest when remote digest changed", async () => {
+    const fs = new BaiduFileSystem("/apps", "token");
+    vi.spyOn(fs, "list").mockResolvedValue([
+      {
+        name: "test.txt",
+        path: "/apps",
+        size: 1,
+        digest: "new-md5",
+        createtime: 1,
+        updatetime: 1,
+      },
+    ]);
+
+    const writer = await fs.create("test.txt", { expectedDigest: "old-md5" });
+
+    await expect(writer.write("content")).rejects.toMatchObject({
+      provider: "baidu",
+      conflict: true,
+    });
+  });
+
   it("delete should be idempotent when Baidu reports file missing", async () => {
     const fetchMock = vi.fn().mockResolvedValue({
       json: async () => ({ errno: -9 }),

packages/filesystem/baidu/baidu.ts

@@ -31,15 +31,15 @@ export default class BaiduFileSystem implements FileSystem {
   }
 
   async create(path: string, opts?: FileCreateOptions): Promise<FileWriter> {
-    if (opts?.expectedDigest || opts?.expectedVersion || opts?.createOnly || opts?.overwrite === false) {
+    if (opts?.expectedVersion) {
       throw new FileSystemError({
         provider: "baidu",
-        message: "Baidu filesystem does not support conditional writes",
+        message: "Baidu filesystem does not expose a version token for conditional writes",
         code: "unsupported_conditional_write",
         unsupported: true,
       });
     }
-    return new BaiduFileWriter(this, joinPath(this.path, path));
+    return new BaiduFileWriter(this, joinPath(this.path, path), opts);
   }
 
   async createDir(dir: string, _opts?: FileCreateOptions): Promise<void> {

packages/filesystem/baidu/rw.ts

@@ -1,4 +1,5 @@
-import type { FileInfo, FileReader, FileWriter } from "../filesystem";
+import { FileSystemError } from "../error";
+import type { FileCreateOptions, FileInfo, FileReader, FileWriter } from "../filesystem";
 import { calculateMd5, md5OfText } from "@App/pkg/utils/crypto";
 import type BaiduFileSystem from "./baidu";
 
@@ -38,9 +39,12 @@ export class BaiduFileWriter implements FileWriter {
 
   fs: BaiduFileSystem;
 
-  constructor(fs: BaiduFileSystem, path: string) {
+  opts?: FileCreateOptions;
+
+  constructor(fs: BaiduFileSystem, path: string, opts?: FileCreateOptions) {
     this.fs = fs;
     this.path = path;
+    this.opts = opts;
   }
 
   size(content: string | Blob) {
@@ -58,6 +62,8 @@ export class BaiduFileWriter implements FileWriter {
   }
 
   async write(content: string | Blob): Promise<void> {
+    await this.checkWritePrecondition();
+
     // 预上传获取id
     const size = this.size(content).toString();
     const md5 = await this.md5(content);
@@ -124,4 +130,35 @@ export class BaiduFileWriter implements FileWriter {
       throw new Error(JSON.stringify(data));
     }
   }
+
+  private async checkWritePrecondition(): Promise<void> {
+    if (!this.opts?.expectedDigest && !this.opts?.createOnly && this.opts?.overwrite !== false) {
+      return;
+    }
+    const targetName = this.path.substring(this.path.lastIndexOf("/") + 1);
+    const existing = (await this.fs.list()).find((file) => file.name === targetName);
+
+    if (this.opts?.createOnly || this.opts?.overwrite === false) {
+      if (existing) {
+        throw new FileSystemError({
+          provider: "baidu",
+          message: `File already exists: ${this.path}`,
+          status: 409,
+          code: "nameAlreadyExists",
+          conflict: true,
+        });
+      }
+      return;
+    }
+
+    if (this.opts?.expectedDigest && existing?.digest !== this.opts.expectedDigest) {
+      throw new FileSystemError({
+        provider: "baidu",
+        message: `Baidu file digest changed before write: ${this.path}`,
+        status: 412,
+        code: "digestMismatch",
+        conflict: true,
+      });
+    }
+  }
 }

packages/filesystem/googledrive/googledrive.test.ts

@@ -163,6 +163,25 @@ describe("GoogleDriveFileSystem", () => {
     });
   });
 
+  it("writer should rollback and reject createOnly when Google Drive creates a duplicate name", async () => {
+    const fs = new GoogleDriveFileSystem("/", "token");
+    const writer = await fs.create("file.txt", { createOnly: true });
+    vi.spyOn(fs, "findFileInDirectory").mockResolvedValue(null);
+    vi.spyOn(fs, "findFilesInDirectory").mockResolvedValue([{ id: "other-file" }, { id: "created-file" }]);
+    const requestSpy = vi.spyOn(fs, "request").mockResolvedValueOnce({ id: "created-file" }).mockResolvedValueOnce({});
+
+    await expect(writer.write("content")).rejects.toMatchObject({
+      provider: "googledrive",
+      conflict: true,
+    });
+
+    expect(requestSpy).toHaveBeenCalledTimes(2);
+    expect(requestSpy.mock.calls[1][0]).toBe(
+      "https://www.googleapis.com/drive/v3/files/created-file?spaces=appDataFolder"
+    );
+    expect((requestSpy.mock.calls[1][1] as RequestInit).method).toBe("DELETE");
+  });
+
   it("list should clear stale path cache and retry once on provider 404", async () => {
     const fs = new GoogleDriveFileSystem("/Base", "token");
     const notFoundError = new FileSystemError({

packages/filesystem/googledrive/googledrive.ts

@@ -361,15 +361,17 @@ export default class GoogleDriveFileSystem implements FileSystem {
 
   // 辅助方法：在指定目录中查找文件
   async findFileInDirectory(fileName: string, parentId: string): Promise<string | null> {
+    const files = await this.findFilesInDirectory(fileName, parentId);
+    return files[0]?.id || null;
+  }
+
+  async findFilesInDirectory(fileName: string, parentId: string): Promise<Array<{ id: string }>> {
     const query = `name='${fileName}' and '${parentId}' in parents and trashed=false and mimeType!='application/vnd.google-apps.folder'`;
     const response = await this.request(
       `https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id)&spaces=appDataFolder`
     );
 
-    if (response.files && response.files.length > 0) {
-      return response.files[0].id;
-    }
-    return null;
+    return response.files || [];
   }
 
   clearPathCache(path?: string): void {

packages/filesystem/googledrive/rw.ts

@@ -137,17 +137,45 @@ export class GoogleDriveFileWriter implements FileWriter {
     const headers =
       this.opts?.createOnly || this.opts?.overwrite === false ? new Headers({ "If-None-Match": "*" }) : undefined;
 
-    await this.fs.request(
-      `https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart&spaces=appDataFolder`,
+    const created = await this.fs.request(
+      `https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart&spaces=appDataFolder&fields=id`,
       {
         method: "POST",
         body: formData,
         ...(headers ? { headers } : {}),
       }
     );
 
+    if (this.opts?.createOnly || this.opts?.overwrite === false) {
+      await this.rejectDuplicateCreate(fileName, parentId, created?.id);
+    }
+
     return Promise.resolve();
   }
+
+  private async rejectDuplicateCreate(fileName: string, parentId: string, createdId?: string): Promise<void> {
+    if (!createdId) {
+      return;
+    }
+    const files = await this.fs.findFilesInDirectory(fileName, parentId);
+    if (!files.length || (files.length === 1 && files[0].id === createdId)) {
+      return;
+    }
+    try {
+      await this.fs.request(`https://www.googleapis.com/drive/v3/files/${createdId}?spaces=appDataFolder`, {
+        method: "DELETE",
+      });
+    } catch {
+      // Best-effort cleanup. The conflict still prevents local digest/status from being advanced.
+    }
+    throw new FileSystemError({
+      provider: "googledrive",
+      message: `Duplicate Google Drive file detected after create: ${this.path}`,
+      status: 409,
+      code: "nameAlreadyExists",
+      conflict: true,
+    });
+  }
 }
 
 function parseGoogleDriveVersion(version?: string): { fileId: string; matchToken?: string } | undefined {

src/app/service/service_worker/synchronize.test.ts

@@ -762,6 +762,45 @@ console.log("ok");`
     expect(fs.create).not.toHaveBeenCalledWith("scriptcat-sync.json", expect.anything());
   });
 
+  it("skips status and digest update when any push task fails", async () => {
+    const error = new Error("network failed after partial write");
+    const fs = createFs({
+      list: vi.fn().mockResolvedValueOnce([]),
+    });
+    const service = new SynchronizeService(
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {
+        scriptCodeDAO: {
+          get: vi.fn().mockResolvedValue({ code: "// code" }),
+        },
+        all: vi.fn().mockResolvedValue([
+          {
+            uuid: "push-uuid",
+            name: "push",
+            updatetime: 1,
+            createtime: 1,
+            status: 1,
+            sort: 0,
+            metadata: {},
+          },
+        ]),
+      } as any
+    );
+    vi.spyOn(service, "pushScript").mockRejectedValue(error);
+    const updateDigestSpy = vi.spyOn(service, "updateFileDigest");
+
+    await service.syncOnce(syncConfig, fs);
+
+    expect(updateDigestSpy).not.toHaveBeenCalled();
+    expect(fs.create).not.toHaveBeenCalledWith("scriptcat-sync.json", expect.anything());
+  });
+
   it("scriptInstall enters cloud_sync queue and updates digest after push", async () => {
     let releaseSync!: () => void;
     const syncGate = new Promise<void>((resolve) => {

src/app/service/service_worker/synchronize.ts

@@ -498,8 +498,13 @@ export class SynchronizeService {
         Object.assign(pushedFileDigestMap, ret.value);
       }
     });
-    if (syncResults.some((ret) => ret.status === "rejected" && isConflictError(ret.reason))) {
-      this.logger.warn("skip status and digest update because cloud sync hit remote conflict");
+    const rejected = syncResults.filter((ret) => ret.status === "rejected");
+    if (rejected.length) {
+      const hasConflict = rejected.some((ret) => isConflictError(ret.reason));
+      this.logger.warn("skip status and digest update because cloud sync task failed", {
+        conflict: hasConflict,
+        failed: rejected.length,
+      });
       return;
     }
     // 同步状态