✨ 增加脚本回收站功能

src/app/repo/test-helpers.ts

@@ -44,14 +44,14 @@ export function createMockOPFS() {
           if (opts?.create) {
             store.set("__dir__" + name, new Map());
           } else {
-            throw new Error("Not found");
+            throw new DOMException("Not found", "NotFoundError");
           }
         }
         return createMockDirHandle(store.get("__dir__" + name));
       }),
       getFileHandle: vi.fn(async (name: string, opts?: { create?: boolean }) => {
         if (!store.has(name) && !opts?.create) {
-          throw new Error("Not found");
+          throw new DOMException("Not found", "NotFoundError");
         }
         if (!store.has(name)) {
           store.set(name, "");
@@ -62,6 +62,15 @@ export function createMockOPFS() {
         store.delete(name);
         store.delete("__dir__" + name);
       }),
+      async *entries() {
+        for (const [name, value] of store) {
+          if (name.startsWith("__dir__")) {
+            yield [name.slice(7), createMockDirHandle(value)];
+          } else {
+            yield [name, createMockFileHandle(name, store)];
+          }
+        }
+      },
     };
   }
 

src/app/repo/trash_script.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { initTestEnv } from "@Tests/utils";
+import { TrashScriptDAO, type TrashScript } from "./trash_script";
+import { SCRIPT_TYPE_NORMAL, SCRIPT_STATUS_ENABLE, SCRIPT_RUN_STATUS_COMPLETE } from "./scripts";
+import { createMockOPFS } from "./test-helpers";
+
+initTestEnv();
+
+beforeEach(() => createMockOPFS());
+
+const makeTrashScript = (overrides: Partial<TrashScript> = {}): TrashScript => ({
+  uuid: "uuid-trash-1",
+  name: "测试脚本",
+  namespace: "test-namespace",
+  type: SCRIPT_TYPE_NORMAL,
+  status: SCRIPT_STATUS_ENABLE,
+  sort: 0,
+  runStatus: SCRIPT_RUN_STATUS_COMPLETE,
+  createtime: Date.now(),
+  checktime: Date.now(),
+  metadata: {},
+  deleteTime: Date.now(),
+  deleteBy: "user",
+  ...overrides,
+});
+
+describe("TrashScriptDAO", () => {
+  let dao: TrashScriptDAO;
+
+  beforeEach(() => {
+    dao = new TrashScriptDAO();
+  });
+
+  it("应能保存回收站脚本并按 uuid 取回,且保留删除元数据", async () => {
+    await dao.save(makeTrashScript({ uuid: "u1", deleteTime: 1234, deleteBy: "sync" }));
+    const got = await dao.get("u1");
+    expect(got?.uuid).toBe("u1");
+    expect(got?.deleteTime).toBe(1234);
+    expect(got?.deleteBy).toBe("sync");
+  });
+
+  it("应能按 name+namespace 查回收站脚本", async () => {
+    await dao.save(makeTrashScript({ uuid: "u3", name: "查我", namespace: "ns-a" }));
+    expect((await dao.findByNameAndNamespace("查我", "ns-a"))?.uuid).toBe("u3");
+    expect(await dao.findByNameAndNamespace("查我", "ns-b")).toBeUndefined();
+  });
+
+  it("应能批量删除回收站脚本", async () => {
+    await dao.save(makeTrashScript({ uuid: "u4" }));
+    await dao.save(makeTrashScript({ uuid: "u5" }));
+    await dao.deletes(["u4", "u5"]);
+    expect(await dao.all()).toHaveLength(0);
+  });
+});

src/app/repo/trash_script.ts

@@ -0,0 +1,155 @@
+import type { Script } from "./scripts";
+import type { InstallSource } from "../service/service_worker/types";
+
+const TRASH_DIR = "trash/scripts";
+
+/** 回收站中的脚本:原脚本 + 删除元数据 */
+export interface TrashScript extends Script {
+  /** 进入回收站的时间戳(毫秒) */
+  deleteTime: number;
+  /** 删除来源 */
+  deleteBy: InstallSource;
+}
+
+interface TrashScriptFile {
+  script: TrashScript;
+  code?: string;
+}
+
+interface IterableDirectoryHandle {
+  entries(): AsyncIterableIterator<[string, FileSystemDirectoryHandle | FileSystemFileHandle]>;
+}
+
+async function getTrashDir(): Promise<FileSystemDirectoryHandle> {
+  let dir = await navigator.storage.getDirectory();
+  for (const part of TRASH_DIR.split("/")) {
+    dir = await dir.getDirectoryHandle(part, { create: true });
+  }
+  return dir;
+}
+
+function filename(uuid: string): string {
+  return `${encodeURIComponent(uuid)}.json`;
+}
+
+function clone<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T;
+}
+
+function isNotFoundError(error: unknown): boolean {
+  return error instanceof DOMException && error.name === "NotFoundError";
+}
+
+/** 回收站专用 OPFS DAO。 */
+export class TrashScriptDAO {
+  public useCache = false;
+
+  private cache?: Map<string, TrashScriptFile>;
+
+  private cacheLoaded = false;
+
+  public enableCache(): void {
+    this.useCache = true;
+  }
+
+  private async readFile(uuid: string): Promise<TrashScriptFile | undefined> {
+    const cached = this.cache?.get(uuid);
+    if (this.useCache && cached) return clone(cached);
+    try {
+      const dir = await getTrashDir();
+      const handle = await dir.getFileHandle(filename(uuid));
+      const data = JSON.parse(await (await handle.getFile()).text()) as TrashScriptFile;
+      if (this.useCache) {
+        this.cache ??= new Map();
+        this.cache.set(uuid, data);
+      }
+      return clone(data);
+    } catch (error) {
+      if (isNotFoundError(error)) return undefined;
+      throw error;
+    }
+  }
+
+  private async writeFile(uuid: string, data: TrashScriptFile): Promise<void> {
+    const dir = await getTrashDir();
+    const handle = await dir.getFileHandle(filename(uuid), { create: true });
+    const writable = await handle.createWritable();
+    await writable.write(JSON.stringify(data));
+    await writable.close();
+    if (this.useCache) {
+      this.cache ??= new Map();
+      this.cache.set(uuid, clone(data));
+    }
+  }
+
+  private async loadAll(): Promise<Map<string, TrashScriptFile>> {
+    if (this.useCache && this.cacheLoaded && this.cache) {
+      return this.cache;
+    }
+    const result = new Map<string, TrashScriptFile>();
+    const dir = await getTrashDir();
+    for await (const [name, handle] of (dir as unknown as IterableDirectoryHandle).entries()) {
+      if (handle.kind !== "file" || !name.endsWith(".json")) continue;
+      const fileHandle = handle as FileSystemFileHandle;
+      const data = JSON.parse(await (await fileHandle.getFile()).text()) as TrashScriptFile;
+      result.set(data.script.uuid, data);
+    }
+    if (this.useCache) {
+      this.cache = result;
+      this.cacheLoaded = true;
+    }
+    return result;
+  }
+
+  public async save(val: TrashScript, code?: string): Promise<TrashScript> {
+    const old = code === undefined ? await this.readFile(val.uuid) : undefined;
+    await this.writeFile(val.uuid, { script: val, code: code ?? old?.code });
+    return val;
+  }
+
+  public async get(key: string): Promise<TrashScript | undefined> {
+    return (await this.readFile(key))?.script;
+  }
+
+  public async getCode(key: string): Promise<string | undefined> {
+    return (await this.readFile(key))?.code;
+  }
+
+  public async gets(keys: string[]): Promise<(TrashScript | undefined)[]> {
+    return Promise.all(keys.map((key) => this.get(key)));
+  }
+
+  public async find(filters?: (key: string, value: TrashScript) => boolean): Promise<TrashScript[]> {
+    const result: TrashScript[] = [];
+    for (const [key, data] of await this.loadAll()) {
+      if (!filters || filters(key, data.script)) result.push(clone(data.script));
+    }
+    return result;
+  }
+
+  public async all(): Promise<TrashScript[]> {
+    return this.find();
+  }
+
+  public async findOne(filters?: (key: string, value: TrashScript) => boolean): Promise<TrashScript | undefined> {
+    return (await this.find(filters))[0];
+  }
+
+  public findByNameAndNamespace(name: string, namespace: string): Promise<TrashScript | undefined> {
+    return this.findOne((_key, value) => value.name === name && (!namespace || value.namespace === namespace));
+  }
+
+  public async delete(key: string): Promise<void> {
+    const dir = await getTrashDir();
+    try {
+      await dir.removeEntry(filename(key));
+    } catch (error) {
+      if (!isNotFoundError(error)) throw error;
+    }
+    this.cache?.delete(key);
+  }
+
+  public async deletes(keys: string[]): Promise<void> {
+    await Promise.all(keys.map((key) => this.delete(key)));
+  }
+}

src/app/service/offscreen/script.ts

@@ -75,7 +75,7 @@ export class ScriptService {
         disableScript(this.windowMessage, data.script.uuid);
       }
     });
-    this.messageQueue.subscribe<TDeleteScript[]>("deleteScripts", async (data) => {
+    this.messageQueue.subscribe<TDeleteScript[]>("trashScripts", async (data) => {
       for (const { uuid, type } of data) {
         // 只发送后台脚本和定时脚本
         if (type === SCRIPT_TYPE_BACKGROUND || type === SCRIPT_TYPE_CRONTAB) {

src/app/service/service_worker/client.ts

@@ -19,9 +19,11 @@ import type {
   ScriptService,
   TCheckScriptUpdateOption,
   TOpenBatchUpdatePageOption,
+  TRestoreResult,
   TScriptInstallParam,
   TScriptInstallReturn,
 } from "./script";
+import type { TrashScript } from "@App/app/repo/trash_script";
 import { encodeRValue, type TKeyValuePair } from "@App/pkg/utils/message_value";
 import { type TSetValuesParams } from "./value";
 import type { LocalBackupExport } from "./synchronize";
@@ -60,6 +62,18 @@ export class ScriptClient extends Client {
     return this.do("deletes", uuids);
   }
 
+  restores(uuids: string[]) {
+    return this.do<TRestoreResult>("restores", uuids);
+  }
+
+  purges(uuids: string[]) {
+    return this.do<boolean>("purges", uuids);
+  }
+
+  getTrashScripts() {
+    return this.do<TrashScript[]>("getTrashScripts");
+  }
+
   enable(uuid: string, enable: boolean) {
     return this.do("enable", { uuid, enable });
   }

src/app/service/service_worker/index.ts

@@ -187,6 +187,9 @@ export default class ServiceWorkerManager {
           // 避免浏览器打开时立即清除。先等tabs载入一下
           setTimeout(cleanupStaleTempStorageEntries, needsWarmupDelay ? 45_000 : 100);
           break;
+        case "cleanupTrash":
+          script.cleanupExpiredTrash();
+          break;
       }
     });
     // 12小时检查一次扩展更新
@@ -246,6 +249,26 @@ export default class ServiceWorkerManager {
     // 定期清理过期的临时安装信息
     chrome.alarms.create("cleanupTempStorage", { periodInMinutes: 30 });
 
+    // 定期清理回收站中过期的脚本(30 天精度无需更细)。
+    // 必须先 get 再 create(同 checkUpdate/agentTaskScheduler):create 同名 alarm 会重置倒计时,
+    // 活跃使用时 SW 频繁冷启动,无条件 create 会让 12 小时的闹钟永远数不满、清理永远不触发。
+    chrome.alarms.get("cleanupTrash", (alarm) => {
+      const lastError = chrome.runtime.lastError;
+      if (lastError) {
+        console.error("chrome.runtime.lastError in chrome.alarms.get:", lastError);
+        // 非预期的异常API错误，停止处理
+      }
+      if (!alarm) {
+        chrome.alarms.create("cleanupTrash", { periodInMinutes: 12 * 60 }, () => {
+          const lastError = chrome.runtime.lastError;
+          if (lastError) {
+            console.error("chrome.runtime.lastError in chrome.alarms.create:", lastError);
+            console.error("Chrome alarm is unable to create. Please check whether limit is reached.");
+          }
+        });
+      }
+    });
+
     // 一些只需启动时运行一次的任务
     cacheInstance.getOrSet("extension_initialized", () => {
       // 启动一次云同步

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

@@ -146,7 +146,7 @@ describe("PopupService 删除脚本后 Popup 菜单残留清理", () => {
     expect(scriptDAO.gets).toHaveBeenCalledWith([deletedUuid]);
   });
 
-  it("deleteScripts 事件应从所有标签页缓存（包含后台 -1）清除已删脚本，并清理待处理菜单命令", async () => {
+  it("trashScripts 事件应从所有标签页缓存（包含后台 -1）清除已删脚本，并清理待处理菜单命令", async () => {
     const deletedUuid = "deleted-script";
     const liveUuid = "live-script";
     await cacheInstance.set(`${CACHE_KEY_TAB_SCRIPT}${1}`, [createMenu(deletedUuid), createMenu(liveUuid)]);
@@ -163,7 +163,9 @@ describe("PopupService 删除脚本后 Popup 菜单残留清理", () => {
     ] as never);
     service.dealBackgroundScriptInstall();
 
-    const [deleteHandler] = subscriptions.get("deleteScripts") || [];
+    // 删除脚本现在语义为“移入回收站”，该清理逻辑随 popup.ts 的订阅一并迁移到了 trashScripts 事件
+    // （事件名变更，handler 本身未变）。
+    const [deleteHandler] = subscriptions.get("trashScripts") || [];
     expect(deleteHandler).toBeDefined();
     await deleteHandler!([
       { uuid: deletedUuid, storageName: "deleted-script", type: SCRIPT_TYPE_NORMAL },

src/app/service/service_worker/popup.ts

@@ -601,7 +601,7 @@ export class PopupService {
         }
       });
     });
-    this.mq.subscribe<TDeleteScript[]>("deleteScripts", async (data) => {
+    this.mq.subscribe<TDeleteScript[]>("trashScripts", async (data) => {
       const changed = await this.removeDeletedScriptsFromPopupCaches(data.map(({ uuid }) => uuid));
       if (changed) {
         this.updateBadgeIcon();

src/app/service/service_worker/runtime.ts

@@ -593,7 +593,7 @@ export class RuntimeService {
     });
 
     // 监听脚本删除
-    this.mq.subscribe<TDeleteScript[]>("deleteScripts", async (data) => {
+    this.mq.subscribe<TDeleteScript[]>("trashScripts", async (data) => {
       // 显式提前失效，确保在任何 await 之前就清掉陈旧的 disabled 匹配器。
       // 虽然下方 updateSorter() 内部也会调用 invalidateDisabledMatcher()，但此处与 installScript 保持一致：
       // 由于 updateSorter() 位于 await 之后，必须先在最前面显式失效一次。