♻️ AgentTaskRunRepo 改用 OPFS 存储

AgentTaskRun 原本存在 chrome.storage.local（键前缀 agent_task_run:），
存在几个问题：配额压力、listRuns 全表扫描、缓存常驻内存。

改为 OPFS 后：
- 存储路径：agents/task_runs/{taskId}.json（内含 run[] 降序）
- listRuns O(全表) → O(单文件 parse)
- 环形缓冲：每任务保留最近 100 条（append 时自动裁剪）
- Agent 体系存储后端统一到 OPFS

改动：
- agent_task.ts: AgentTaskRunRepo extends Repo → extends OPFSRepo
- task_scheduler.ts: updateRun 签名加 taskId 参数
- 测试：添加 OPFS mock + 2 个新用例（环形缓冲 / 更新不存在 id）

Agent 功能尚未发布，无需考虑旧数据迁移。
Typecheck 0 错误，1736 测试全绿（+2 新用例）

Author: CodFrm

src/app/repo/agent_task.test.ts

@@ -1,7 +1,82 @@
-import { describe, expect, it, beforeEach } from "vitest";
+import { describe, expect, it, vi, beforeEach } from "vitest";
 import { AgentTaskRepo, AgentTaskRunRepo } from "./agent_task";
 import type { AgentTask, AgentTaskRun } from "@App/app/service/agent/core/types";
 
+// Mock OPFS 文件系统
+function createMockOPFS() {
+  function createMockWritable() {
+    let data: any = null;
+    return {
+      write: vi.fn(async (content: any) => {
+        data = content;
+      }),
+      close: vi.fn(async () => {}),
+      getData: () => data,
+    };
+  }
+
+  function createMockFileHandle(name: string, dir: Map<string, any>) {
+    return {
+      kind: "file" as const,
+      getFile: vi.fn(async () => {
+        const content = dir.get(name);
+        if (typeof content === "string") return new Blob([content], { type: "application/json" });
+        return new Blob([""], { type: "application/json" });
+      }),
+      createWritable: vi.fn(async () => {
+        const writable = createMockWritable();
+        const origClose = writable.close;
+        writable.close = vi.fn(async () => {
+          const written = writable.getData();
+          dir.set(name, written);
+          await origClose();
+        });
+        return writable;
+      }),
+    };
+  }
+
+  function createMockDirHandle(store: Map<string, any>): any {
+    return {
+      kind: "directory" as const,
+      getDirectoryHandle: vi.fn(async (name: string, opts?: { create?: boolean }) => {
+        if (!store.has("__dir__" + name)) {
+          if (opts?.create) {
+            store.set("__dir__" + name, new Map());
+          } else {
+            throw new Error("Not found");
+          }
+        }
+        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");
+        }
+        if (!store.has(name)) {
+          store.set(name, "");
+        }
+        return createMockFileHandle(name, store);
+      }),
+      removeEntry: vi.fn(async (name: string) => {
+        store.delete(name);
+        store.delete("__dir__" + name);
+      }),
+    };
+  }
+
+  const rootStore = new Map<string, any>();
+  const mockRoot = createMockDirHandle(rootStore);
+
+  Object.defineProperty(navigator, "storage", {
+    value: {
+      getDirectory: vi.fn(async () => mockRoot),
+    },
+    configurable: true,
+    writable: true,
+  });
+}
+
 function makeTask(overrides: Partial<AgentTask> = {}): AgentTask {
   return {
     id: "task-1",
@@ -26,45 +101,46 @@ function makeRun(overrides: Partial<AgentTaskRun> = {}): AgentTaskRun {
   };
 }
 
-describe.concurrent("AgentTaskRepo", () => {
+describe("AgentTaskRepo", () => {
   let repo: AgentTaskRepo;
 
   beforeEach(() => {
+    createMockOPFS();
     repo = new AgentTaskRepo();
   });
 
-  it.concurrent("saveTask / getTask CRUD", async () => {
-    const task = makeTask();
+  it("saveTask / getTask CRUD", async () => {
+    const task = makeTask({ id: "crud-task" });
     await repo.saveTask(task);
-    const result = await repo.getTask("task-1");
+    const result = await repo.getTask("crud-task");
     expect(result).toBeDefined();
     expect(result!.name).toBe("测试任务");
   });
 
-  it.concurrent("listTasks 返回所有任务", async () => {
-    await repo.saveTask(makeTask({ id: "t-a", name: "A" }));
-    await repo.saveTask(makeTask({ id: "t-b", name: "B" }));
+  it("listTasks 返回所有任务", async () => {
+    await repo.saveTask(makeTask({ id: "list-a", name: "A" }));
+    await repo.saveTask(makeTask({ id: "list-b", name: "B" }));
     const list = await repo.listTasks();
     expect(list.length).toBeGreaterThanOrEqual(2);
     const names = list.map((t) => t.name);
     expect(names).toContain("A");
     expect(names).toContain("B");
   });
 
-  it.concurrent("removeTask 删除任务", async () => {
+  it("removeTask 删除任务", async () => {
     const task = makeTask({ id: "t-del" });
     await repo.saveTask(task);
     await repo.removeTask("t-del");
     const result = await repo.getTask("t-del");
     expect(result).toBeUndefined();
   });
 
-  it.concurrent("removeTask 同时清理关联的 runs", async () => {
+  it("removeTask 同时清理关联的 runs", async () => {
     const taskId = "t-clean";
     await repo.saveTask(makeTask({ id: taskId }));
     const runRepo = new AgentTaskRunRepo();
-    await runRepo.appendRun(makeRun({ id: "r1", taskId }));
-    await runRepo.appendRun(makeRun({ id: "r2", taskId }));
+    await runRepo.appendRun(makeRun({ id: "r1", taskId, starttime: 1000 }));
+    await runRepo.appendRun(makeRun({ id: "r2", taskId, starttime: 2000 }));
 
     await repo.removeTask(taskId);
 
@@ -73,28 +149,29 @@ describe.concurrent("AgentTaskRepo", () => {
   });
 });
 
-describe.concurrent("AgentTaskRunRepo", () => {
+describe("AgentTaskRunRepo", () => {
   let repo: AgentTaskRunRepo;
 
   beforeEach(() => {
+    createMockOPFS();
     repo = new AgentTaskRunRepo();
   });
 
-  it.concurrent("appendRun / listRuns", async () => {
+  it("appendRun / listRuns 按 starttime 降序", async () => {
     const taskId = "task-run-test";
     await repo.appendRun(makeRun({ id: "r-a", taskId, starttime: 1000 }));
     await repo.appendRun(makeRun({ id: "r-b", taskId, starttime: 2000 }));
     await repo.appendRun(makeRun({ id: "r-c", taskId, starttime: 3000 }));
 
     const runs = await repo.listRuns(taskId);
     expect(runs.length).toBe(3);
-    // 按 starttime 降序
+    // 按 starttime 降序（最新在前）
     expect(runs[0].id).toBe("r-c");
     expect(runs[1].id).toBe("r-b");
     expect(runs[2].id).toBe("r-a");
   });
 
-  it.concurrent("listRuns 限制返回条数", async () => {
+  it("listRuns 限制返回条数", async () => {
     const taskId = "task-limit";
     for (let i = 0; i < 5; i++) {
       await repo.appendRun(makeRun({ id: `rl-${i}`, taskId, starttime: i * 1000 }));
@@ -103,7 +180,7 @@ describe.concurrent("AgentTaskRunRepo", () => {
     expect(runs.length).toBe(3);
   });
 
-  it.concurrent("clearRuns 清理指定任务的运行历史", async () => {
+  it("clearRuns 清理指定任务的运行历史", async () => {
     const taskId = "task-clear";
     await repo.appendRun(makeRun({ id: "rc-1", taskId }));
     await repo.appendRun(makeRun({ id: "rc-2", taskId }));
@@ -119,11 +196,31 @@ describe.concurrent("AgentTaskRunRepo", () => {
     expect(otherRuns).toHaveLength(1);
   });
 
-  it.concurrent("updateRun 更新运行状态", async () => {
+  it("updateRun 更新运行状态", async () => {
     await repo.appendRun(makeRun({ id: "r-upd", taskId: "t-upd" }));
-    await repo.updateRun("r-upd", { status: "success", endtime: Date.now() });
+    await repo.updateRun("t-upd", "r-upd", { status: "success", endtime: 99999 });
     const runs = await repo.listRuns("t-upd");
     expect(runs[0].status).toBe("success");
-    expect(runs[0].endtime).toBeDefined();
+    expect(runs[0].endtime).toBe(99999);
+  });
+
+  it("updateRun 找不到 id 时静默忽略", async () => {
+    await repo.appendRun(makeRun({ id: "r-exists", taskId: "t-miss" }));
+    await repo.updateRun("t-miss", "r-nonexistent", { status: "error" });
+    const runs = await repo.listRuns("t-miss");
+    expect(runs).toHaveLength(1);
+    expect(runs[0].status).toBe("running");
+  });
+
+  it("appendRun 超过 MAX_RUNS_PER_TASK 时裁剪最老记录", async () => {
+    const taskId = "task-ring";
+    for (let i = 0; i < 105; i++) {
+      await repo.appendRun(makeRun({ id: `rr-${i}`, taskId, starttime: i }));
+    }
+    const runs = await repo.listRuns(taskId, 200);
+    expect(runs.length).toBe(100);
+    // 最新的在前，最老 5 条被裁剪掉（rr-0 ~ rr-4）
+    expect(runs[0].id).toBe("rr-104");
+    expect(runs[99].id).toBe("rr-5");
   });
 });

src/app/repo/agent_task.ts

@@ -1,5 +1,6 @@
 import type { AgentTask, AgentTaskRun } from "@App/app/service/agent/core/types";
 import { Repo } from "./repo";
+import { OPFSRepo } from "./opfs_repo";
 
 export class AgentTaskRepo extends Repo<AgentTask> {
   constructor() {
@@ -27,32 +28,41 @@ export class AgentTaskRepo extends Repo<AgentTask> {
   }
 }
 
-export class AgentTaskRunRepo extends Repo<AgentTaskRun> {
+const MAX_RUNS_PER_TASK = 100;
+
+export class AgentTaskRunRepo extends OPFSRepo {
   constructor() {
-    super("agent_task_run:");
-    this.enableCache();
+    super("task_runs");
+  }
+
+  private filename(taskId: string): string {
+    return `${taskId}.json`;
   }
 
   async appendRun(run: AgentTaskRun): Promise<void> {
-    await this._save(run.id, run);
+    const runs = await this.readJsonFile<AgentTaskRun[]>(this.filename(run.taskId), []);
+    runs.unshift(run);
+    // 环形缓冲：超过上限时裁剪最老的记录
+    if (runs.length > MAX_RUNS_PER_TASK) {
+      runs.length = MAX_RUNS_PER_TASK;
+    }
+    await this.writeJsonFile(this.filename(run.taskId), runs);
   }
 
-  async updateRun(id: string, data: Partial<AgentTaskRun>): Promise<void> {
-    await this.update(id, data);
+  async updateRun(taskId: string, id: string, data: Partial<AgentTaskRun>): Promise<void> {
+    const runs = await this.readJsonFile<AgentTaskRun[]>(this.filename(taskId), []);
+    const idx = runs.findIndex((r) => r.id === id);
+    if (idx < 0) return;
+    Object.assign(runs[idx], data);
+    await this.writeJsonFile(this.filename(taskId), runs);
   }
 
   async listRuns(taskId: string, limit = 50): Promise<AgentTaskRun[]> {
-    const all = await this.find((_key, value) => value.taskId === taskId);
-    // 按 starttime 降序排列
-    all.sort((a, b) => b.starttime - a.starttime);
-    return all.slice(0, limit);
+    const runs = await this.readJsonFile<AgentTaskRun[]>(this.filename(taskId), []);
+    return runs.slice(0, limit);
   }
 
   async clearRuns(taskId: string): Promise<void> {
-    const all = await this.find((_key, value) => value.taskId === taskId);
-    if (all.length > 0) {
-      const keys = all.map((r) => r.id);
-      await this.deletes(keys);
-    }
+    await this.deleteFile(this.filename(taskId));
   }
 }

src/app/service/agent/core/task_scheduler.test.ts

@@ -3,6 +3,67 @@ import { AgentTaskScheduler } from "./task_scheduler";
 import { AgentTaskRepo, AgentTaskRunRepo } from "@App/app/repo/agent_task";
 import type { AgentTask } from "@App/app/service/agent/core/types";
 
+// Mock OPFS 文件系统（AgentTaskRunRepo 使用 OPFS 存储）
+function createMockOPFS() {
+  function createMockWritable() {
+    let data: any = null;
+    return {
+      write: vi.fn(async (content: any) => {
+        data = content;
+      }),
+      close: vi.fn(async () => {}),
+      getData: () => data,
+    };
+  }
+  function createMockFileHandle(name: string, dir: Map<string, any>) {
+    return {
+      kind: "file" as const,
+      getFile: vi.fn(async () => {
+        const content = dir.get(name);
+        if (typeof content === "string") return new Blob([content], { type: "application/json" });
+        return new Blob([""], { type: "application/json" });
+      }),
+      createWritable: vi.fn(async () => {
+        const writable = createMockWritable();
+        const origClose = writable.close;
+        writable.close = vi.fn(async () => {
+          dir.set(name, writable.getData());
+          await origClose();
+        });
+        return writable;
+      }),
+    };
+  }
+  function createMockDirHandle(store: Map<string, any>): any {
+    return {
+      kind: "directory" as const,
+      getDirectoryHandle: vi.fn(async (name: string, opts?: { create?: boolean }) => {
+        if (!store.has("__dir__" + name)) {
+          if (opts?.create) store.set("__dir__" + name, new Map());
+          else throw new Error("Not found");
+        }
+        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");
+        if (!store.has(name)) store.set(name, "");
+        return createMockFileHandle(name, store);
+      }),
+      removeEntry: vi.fn(async (name: string) => {
+        store.delete(name);
+        store.delete("__dir__" + name);
+      }),
+    };
+  }
+  const rootStore = new Map<string, any>();
+  const mockRoot = createMockDirHandle(rootStore);
+  Object.defineProperty(navigator, "storage", {
+    value: { getDirectory: vi.fn(async () => mockRoot) },
+    configurable: true,
+    writable: true,
+  });
+}
+
 function makeTask(overrides: Partial<AgentTask> = {}): AgentTask {
   return {
     id: "task-1",
@@ -29,6 +90,7 @@ describe("AgentTaskScheduler", () => {
   let scheduler: AgentTaskScheduler;
 
   beforeEach(() => {
+    createMockOPFS();
     repo = new AgentTaskRepo();
     runRepo = new AgentTaskRunRepo();
     internalExecutor = vi
@@ -88,10 +150,11 @@ describe("AgentTaskScheduler", () => {
 
     await scheduler.tick();
 
-    // 等待第一次执行开始
+    // 等待 executor 被调用（表明已经过 appendRun）
     await vi.waitFor(() => {
-      expect(scheduler.isRunning("running-1")).toBe(true);
+      expect(internalExecutor).toHaveBeenCalledTimes(1);
     });
+    expect(scheduler.isRunning("running-1")).toBe(true);
 
     // 再次 tick 不应重复执行
     await scheduler.tick();

src/app/service/agent/core/task_scheduler.ts

@@ -89,7 +89,7 @@ export class AgentTaskScheduler {
         task.lastRunError = run.error;
       } finally {
         // 更新 run 记录
-        await this.runRepo.updateRun(run.id, {
+        await this.runRepo.updateRun(task.id, run.id, {
           status: run.status,
           endtime: run.endtime,
           error: run.error,