Merge branch 'main' into fix/sync/015c

Author: cyfung1031

example/run-at_context-menu.js

@@ -0,0 +1,20 @@
+// ==UserScript==
+// @name         Context Menu Demo: Search Selection
+// @namespace    https://bbs.tampermonkey.net.cn/
+// @version      0.1.0
+// @description  Demo for @run-at context-menu
+// @author       You
+// @match        *://*/*
+// @run-at       context-menu
+// @grant        GM_openInTab
+// ==/UserScript==
+
+(function () {
+  'use strict';
+  const selectedText = window.getSelection().toString().trim();
+  if (!selectedText) {
+    alert("Please select some texts first.");
+    return;
+  }
+  GM_openInTab(`https://scriptcat.org/search?keyword=${encodeURIComponent(selectedText)}`)
+})();

packages/filesystem/auth.test.ts

@@ -68,4 +68,38 @@ describe("AuthVerify", () => {
     ).resolves.toEqual(["new-access", "new-access", "new-access"]);
     expect(fetchMock).toHaveBeenCalledTimes(1);
   });
+
+  it("concurrent initial token verification should share one auth request and save once", async () => {
+    vi.useFakeTimers();
+    const createSpy = vi.spyOn(chrome.tabs, "create").mockImplementation(() => Promise.resolve({ id: 1 }) as any);
+    const originalGet = (chrome.tabs as any).get;
+    (chrome.tabs as any).get = vi.fn().mockRejectedValue(new Error("closed"));
+    const saveSpy = vi.spyOn(LocalStorageDAO.prototype, "saveValue");
+    const fetchMock = vi.fn().mockResolvedValue({
+      json: vi.fn().mockResolvedValue({
+        code: 0,
+        data: {
+          token: {
+            access_token: "initial-access",
+            refresh_token: "initial-refresh",
+          },
+        },
+      }),
+    } as unknown as Response);
+    vi.stubGlobal("fetch", fetchMock);
+
+    try {
+      const auth = Promise.all([AuthVerify("onedrive"), AuthVerify("onedrive"), AuthVerify("onedrive")]);
+      await vi.advanceTimersByTimeAsync(1000);
+
+      await expect(auth).resolves.toEqual(["initial-access", "initial-access", "initial-access"]);
+      expect(createSpy).toHaveBeenCalledTimes(1);
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      expect(saveSpy).toHaveBeenCalledTimes(1);
+      expect(saveSpy).toHaveBeenCalledWith(key, expect.objectContaining({ accessToken: "initial-access" }));
+    } finally {
+      (chrome.tabs as any).get = originalGet;
+      vi.useRealTimers();
+    }
+  });
 });

packages/filesystem/auth.ts

@@ -74,6 +74,7 @@ export type Token = {
   createtime: number;
 };
 const refreshTokenPromises: Partial<Record<NetDiskType, Promise<string>>> = {};
+const authTokenPromises: Partial<Record<NetDiskType, Promise<Token>>> = {};
 
 function refreshAccessToken(
   netDiskType: NetDiskType,
@@ -126,19 +127,30 @@ export async function AuthVerify(netDiskType: NetDiskType, invalid?: boolean) {
   }
   // token不存在,或者没有accessToken,重新获取
   if (!token || !token.accessToken) {
-    // 强制重新获取token
-    await NetDisk(netDiskType);
-    const resp = await GetNetDiskToken(netDiskType);
-    if (resp.code !== 0) {
-      throw new WarpTokenError(new Error(resp.msg));
+    if (!authTokenPromises[netDiskType]) {
+      const authPromise = (async () => {
+        // 强制重新获取token
+        await NetDisk(netDiskType);
+        const resp = await GetNetDiskToken(netDiskType);
+        if (resp.code !== 0) {
+          throw new WarpTokenError(new Error(resp.msg));
+        }
+        const newToken = {
+          accessToken: resp.data.token.access_token,
+          refreshToken: resp.data.token.refresh_token,
+          createtime: Date.now(),
+        };
+        await localStorageDAO.saveValue(key, newToken);
+        return newToken;
+      })().finally(() => {
+        if (authTokenPromises[netDiskType] === authPromise) {
+          delete authTokenPromises[netDiskType];
+        }
+      });
+      authTokenPromises[netDiskType] = authPromise;
     }
-    token = {
-      accessToken: resp.data.token.access_token,
-      refreshToken: resp.data.token.refresh_token,
-      createtime: Date.now(),
-    };
+    token = await authTokenPromises[netDiskType];
     invalid = false;
-    await localStorageDAO.saveValue(key, token);
   }
   // token未过期(一小时内)及有效则保留，不用刷新token
   const unexpired = Date.now() < token.createtime + 3600000;

packages/filesystem/baidu/baidu.test.ts

@@ -33,6 +33,26 @@ describe("BaiduFileSystem", () => {
     expect(updateDynamicRulesMock).not.toHaveBeenCalled();
   });
 
+  it("create should normalize double slashes in paths", async () => {
+    const fs = new BaiduFileSystem("/apps//ScriptCat", "token");
+
+    const writer = await fs.create("dir//file.user.js");
+
+    expect((writer as any).path).toBe("/apps/ScriptCat/dir/file.user.js");
+  });
+
+  it("delete should normalize double slashes in filelist payload", async () => {
+    const fs = new BaiduFileSystem("/apps//ScriptCat", "token");
+    const request = vi.spyOn(fs, "request").mockResolvedValue({ errno: 0 });
+
+    await fs.delete("dir//file.user.js");
+
+    const [, config] = request.mock.calls[0];
+    expect((config as RequestInit).body).toBe(
+      `async=0&filelist=${encodeURIComponent(JSON.stringify(["/apps/ScriptCat/dir/file.user.js"]))}`
+    );
+  });
+
   it("create should reject expectedVersion as unsupported", async () => {
     const fs = new BaiduFileSystem("/apps", "token");
 

packages/filesystem/dropbox/dropbox.test.ts

@@ -52,6 +52,31 @@ describe("DropboxFileSystem", () => {
     await expect(fs.exists("/test.txt")).rejects.toThrow("invalid_access_token");
   });
 
+  it("create should normalize double slashes after the Dropbox app root", async () => {
+    const fs = new DropboxFileSystem("/ScriptCat//sync", "token");
+
+    const writer = await fs.create("dir//file.user.js");
+
+    expect((writer as any).path).toBe("/sync/dir/file.user.js");
+  });
+
+  it("delete should normalize double slashes after the Dropbox app root", async () => {
+    const fs = new DropboxFileSystem("/ScriptCat//sync", "token");
+    const request = vi.spyOn(fs, "request").mockResolvedValue({});
+
+    await fs.delete("dir//file.user.js");
+
+    expect(request).toHaveBeenCalledWith(
+      "https://api.dropboxapi.com/2/files/delete_v2",
+      expect.objectContaining({
+        method: "POST",
+        body: JSON.stringify({
+          path: "/sync/dir/file.user.js",
+        }),
+      })
+    );
+  });
+
   it("list should expose Dropbox rev as version", async () => {
     const fs = new DropboxFileSystem("/", "token");
     vi.spyOn(fs, "request").mockResolvedValue({

packages/filesystem/googledrive/googledrive.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { LocalStorageDAO } from "@App/app/repo/localStorage";
 import { FileSystemError, isAuthError, isConflictError, isNotFoundError, isRateLimitError } from "../error";
+import { joinPath } from "../utils";
 import GoogleDriveFileSystem from "./googledrive";
 
 function createMockResponse(options: { ok?: boolean; status?: number; text?: string; json?: any }): Response {
@@ -121,6 +122,21 @@ describe("GoogleDriveFileSystem", () => {
     expect(requestSpy).toHaveBeenCalledTimes(1);
   });
 
+  it("create should normalize double slashes in paths", async () => {
+    const fs = new GoogleDriveFileSystem("/ScriptCat//sync", "token");
+
+    const writer = await fs.create("dir//file.user.js");
+
+    expect((writer as any).path).toBe("/ScriptCat/sync/dir/file.user.js");
+  });
+
+  it("clearPathCache should accept normalized paths derived from duplicate slashes", () => {
+    const fs = new GoogleDriveFileSystem("/ScriptCat//sync", "token");
+
+    expect(joinPath("/ScriptCat//sync", "dir//file.user.js")).toBe("/ScriptCat/sync/dir/file.user.js");
+    expect(() => fs.clearPathCache("/ScriptCat//sync/dir")).not.toThrow();
+  });
+
   it("writer should clear stale path cache and retry once on provider 404", async () => {
     const fs = new GoogleDriveFileSystem("/", "token");
     const notFoundError = new FileSystemError({

packages/filesystem/onedrive/onedrive.test.ts

@@ -95,6 +95,27 @@ describe("OneDriveFileSystem", () => {
     await expect(fs.delete("missing.txt")).resolves.toBeUndefined();
   });
 
+  it("create should normalize double slashes in paths", async () => {
+    const fs = new OneDriveFileSystem("/ScriptCat//sync", "token");
+
+    const writer = await fs.create("dir//file.user.js");
+
+    expect((writer as any).path).toBe("/ScriptCat/sync/dir/file.user.js");
+  });
+
+  it("delete should normalize double slashes in URL paths", async () => {
+    const fs = new OneDriveFileSystem("/ScriptCat//sync", "token");
+    const request = vi.spyOn(fs, "request").mockResolvedValue({ status: 204 });
+
+    await fs.delete("dir//file.user.js");
+
+    expect(request).toHaveBeenCalledWith(
+      "https://graph.microsoft.com/v1.0/me/drive/special/approot:/ScriptCat/sync/dir/file.user.js",
+      { method: "DELETE" },
+      true
+    );
+  });
+
   it("delete should send If-Match when expectedVersion is provided", async () => {
     const fs = new OneDriveFileSystem("/", "token");
     const requestSpy = vi.spyOn(fs, "request").mockResolvedValue({} as unknown as Response);