Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
fix(file-cache): 修复版本互删、取消重试和修改时间精度 (#4919)
Dash62cd2bfda82a
diff --git a/apps/desktop/src/main/file-browser/__tests__/remoteFileCacheOwner.test.ts b/apps/desktop/src/main/file-browser/__tests__/remoteFileCacheOwner.test.tsindex a574845ac5..c40d9bf7f9 100644--- a/apps/desktop/src/main/file-browser/__tests__/remoteFileCacheOwner.test.ts+++ b/apps/desktop/src/main/file-browser/__tests__/remoteFileCacheOwner.test.ts@@ -64,9 +64,13 @@ it('cancels the shared executor only after the last consumer releases it', asyncconst firstController = new AbortController();const secondController = new AbortController();let release!: () => void;- const pause = new Promise<void>((resolve) => { release = resolve; });+ const pause = new Promise<void>((resolve) => {+ release = resolve;+ });let started!: () => void;- const ready = new Promise<void>((resolve) => { started = resolve; });+ const ready = new Promise<void>((resolve) => {+ started = resolve;+ });let transferSignal!: AbortSignal;const executor = vi.fn(async (dest: string, _progress: unknown, signal?: AbortSignal) => {transferSignal = signal!;@@ -85,14 +89,13 @@ it('cancels the shared executor only after the last consumer releases it', asyncsecondController.abort();await expect(second).rejects.toThrow('FILE_PEER_CANCELLED');expect(transferSignal.aborted).toBe(true);- // Aborted consumers settle before the transfer's finally cleans staging.- // Join the still-paused transfer without a signal to await that cleanup too.- const drained = expect(fetchRemoteFileToCache(id, executor, vi.fn()))- .rejects.toThrow('FILE_PEER_CANCELLED');+ // Consumers settle before the abandoned executor cleans its staging file.+ // A new reader must now start a fresh transfer, not join this cancelled one.release();- await drained;expect(executor).toHaveBeenCalledOnce();- expect(await fs.readdir(getRemoteFileCacheRoot())).toEqual([]);+ await vi.waitFor(async () => {+ expect(await fs.readdir(getRemoteFileCacheRoot())).toEqual([]);+ });});it('does not return a cache hit or report progress when ownership changes during touch', async () => {diff --git a/apps/desktop/src/main/file-browser/__tests__/remoteFileCacheVersions.test.ts b/apps/desktop/src/main/file-browser/__tests__/remoteFileCacheVersions.test.tsnew file mode 100644index 0000000000..118a51ddbf--- /dev/null+++ b/apps/desktop/src/main/file-browser/__tests__/remoteFileCacheVersions.test.ts@@ -0,0 +1,254 @@+import fs from 'node:fs/promises';+import * as nodeFs from 'node:fs';+import os from 'node:os';+import path from 'node:path';+import { afterEach, expect, it, vi } from 'vitest';++vi.mock('node:fs', async (importOriginal) => {+ const actual = await importOriginal<typeof import('node:fs')>();+ return { ...actual, renameSync: vi.fn(actual.renameSync) };+});++const userDataDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remote-cache-versions-'));+vi.mock('electron', () => ({ app: { getPath: () => userDataDir } }));+vi.mock('../../appSessionState.js', () => ({+ activeOwnerScopeKey: () => 'owner:1',+ dataOwnerStorageKey: (id: string) => id,+}));+vi.mock('../../logger.js', () => ({+ createLogger: () => ({ debug: vi.fn(), warn: vi.fn(), info: vi.fn() }),+}));++const {+ fetchRemoteFileToCache,+ putCachedContent,+ findStaleCached,+ getRemoteFileCacheRoot,+ __cacheTesting,+} = await import('../remote-file-cache');+const id = {+ transport: 'device' as const,+ endpointId: 'device',+ workdir: '/repo',+ relPath: 'a.txt',+ size: 3,+ mtimeMs: 1000.1,+};+function barrier() {+ let resolve!: () => void;+ const promise = new Promise<void>((done) => {+ resolve = done;+ });+ return { promise, resolve };+}+afterEach(async () => {+ vi.restoreAllMocks();+ await fs.rm(userDataDir, { recursive: true, force: true });+});++it.each([true, false])(+ 'retains both returned versions when old finishes last: %s',+ async (oldLast) => {+ const newer = { ...id, mtimeMs: 2000 };+ const oldPath = __cacheTesting.cachePathFor(id);+ const newPath = __cacheTesting.cachePathFor(newer);+ // Make the background cleanup's directory listing deterministic, including+ // both versions. The real filesystem still handles writes, stats and removals.+ vi.spyOn(fs, 'readdir').mockResolvedValue([+ path.basename(oldPath),+ path.basename(newPath),+ ] as never);+ const remove = vi.spyOn(fs, 'rm');+ const started = barrier();+ const release = barrier();+ const slow = fetchRemoteFileToCache(+ oldLast ? id : newer,+ async (dest) => {+ started.resolve();+ await release.promise;+ await fs.writeFile(dest, oldLast ? 'old' : 'new');+ },+ vi.fn(),+ );+ await started.promise;+ try {+ await fetchRemoteFileToCache(+ oldLast ? newer : id,+ (dest) => fs.writeFile(dest, oldLast ? 'new' : 'old'),+ vi.fn(),+ );+ } finally {+ release.resolve();+ }+ await slow;+ await __cacheTesting.evictLru();+ expect(remove.mock.calls.some(([p]) => p === oldPath || p === newPath)).toBe(false);+ expect(await fs.readFile(oldPath, 'utf8')).toBe('old');+ expect(await fs.readFile(newPath, 'utf8')).toBe('new');+ },+);++it.each(['文'.repeat(70), '😀'.repeat(60)])(+ 'bounds multibyte cache components: %s',+ async (stem) => {+ const file = { ...id, relPath: `${stem}.txt` };+ const result = await fetchRemoteFileToCache(file, (dest) => fs.writeFile(dest, 'new'), vi.fn());+ expect(await fs.readFile(result, 'utf8')).toBe('new');+ expect(Buffer.byteLength(path.basename(result), 'utf8')).toBeLessThanOrEqual(255);+ expect(path.extname(result)).toBe('.txt');+ const inline = { ...file, mtimeMs: 2000 };+ await putCachedContent(inline, 'end');+ expect(await fs.readFile(__cacheTesting.cachePathFor(inline), 'utf8')).toBe('end');+ },+);++it('distinguishes same-size sub-millisecond versions in downloads and write-through', async () => {+ await putCachedContent(id, 'old');+ const changed = { ...id, mtimeMs: 1000.2 };+ const executor = vi.fn((dest: string) => fs.writeFile(dest, 'new'));+ const newPath = await fetchRemoteFileToCache(changed, executor, vi.fn());+ expect(executor).toHaveBeenCalledOnce();+ expect(await fs.readFile(newPath, 'utf8')).toBe('new');+ const hit = vi.fn();+ expect(await fetchRemoteFileToCache(changed, hit, vi.fn())).toBe(newPath);+ expect(hit).not.toHaveBeenCalled();+ await putCachedContent({ ...id, mtimeMs: 1000.3 }, 'end');+ expect(await fs.readFile(__cacheTesting.cachePathFor({ ...id, mtimeMs: 1000.3 }), 'utf8')).toBe(+ 'end',+ );+});++it('keeps legacy rounded copies available offline without accepting them as exact hits', async () => {+ const exact = { ...id, mtimeMs: 1000 };+ const currentPath = __cacheTesting.cachePathFor(exact);+ const legacy = path.join(+ getRemoteFileCacheRoot(),+ `${path.basename(currentPath).split('-')[0]}-3-1000-a.txt`,+ );+ await fs.mkdir(getRemoteFileCacheRoot(), { recursive: true });+ await fs.writeFile(legacy, 'old');+ expect(await findStaleCached(exact)).toBe(legacy);+ const executor = vi.fn((dest: string) => fs.writeFile(dest, 'new'));+ expect(await fetchRemoteFileToCache(exact, executor, vi.fn())).toBe(currentPath);+ expect(executor).toHaveBeenCalledOnce();+ expect(await fs.readFile(currentPath, 'utf8')).toBe('new');+});++it.each(['resolve', 'reject'] as const)(+ 'isolates a retry from a cancelled executor that later %ss',+ async (settle) => {+ const oldStarted = barrier();+ const releaseOld = barrier();+ const newStarted = barrier();+ const releaseNew = barrier();+ const controller = new AbortController();+ let oldTemp = '';+ let newTemp = '';+ const oldProgress = vi.fn();+ const first = fetchRemoteFileToCache(+ id,+ async (dest, report) => {+ oldTemp = dest;+ await fs.writeFile(dest, 'old');+ oldStarted.resolve();+ await releaseOld.promise;+ report(3, 3);+ if (settle === 'reject') throw new Error('late failure');+ // Deliberately ignore abort and attempt to finish with stale bytes.+ },+ oldProgress,+ controller.signal,+ );+ await oldStarted.promise;+ controller.abort();+ await expect(first).rejects.toThrow('FILE_PEER_CANCELLED');+ const replacement = vi.fn(async (dest: string) => {+ newTemp = dest;+ await fs.writeFile(dest, 'new');+ newStarted.resolve();+ await releaseNew.promise;+ });+ const retry = fetchRemoteFileToCache(id, replacement, vi.fn());+ try {+ await newStarted.promise;+ expect(newTemp).not.toBe(oldTemp);+ releaseOld.resolve();+ await vi.waitFor(async () => {+ await expect(fs.stat(oldTemp)).rejects.toMatchObject({ code: 'ENOENT' });+ });+ expect(await fs.readFile(newTemp, 'utf8')).toBe('new');+ expect(oldProgress).not.toHaveBeenCalled();+ const unexpected = vi.fn();+ const joined = fetchRemoteFileToCache(id, unexpected, vi.fn());+ releaseNew.resolve();+ const result = await retry;+ expect(await joined).toBe(result);+ expect(unexpected).not.toHaveBeenCalled();+ expect(await fs.readFile(result, 'utf8')).toBe('new');+ } finally {+ releaseOld.resolve();+ releaseNew.resolve();+ await retry.catch(() => undefined);+ }+ },+);++it('does not change the retry result when cancellation meets the publication boundary', async () => {+ const publishing = barrier();+ const release = barrier();+ const cleaned = barrier();+ const rename = fs.rename.bind(fs);+ const { renameSync } = await vi.importActual<typeof import('node:fs')>('node:fs');+ const rm = fs.rm.bind(fs);+ let oldTemp = '';+ // An async publisher may be queued in the OS while a replacement publishes.+ vi.spyOn(fs, 'rename').mockImplementation(async (from, to) => {+ if (from === oldTemp) {+ publishing.resolve();+ await release.promise;+ }+ await rename(from, to);+ });+ vi.spyOn(nodeFs, 'renameSync').mockImplementation((from, to) => {+ renameSync(from, to);+ if (from === oldTemp) publishing.resolve();+ });+ vi.spyOn(fs, 'rm').mockImplementation(async (target, options) => {+ await rm(target, options);+ if (target === oldTemp) cleaned.resolve();+ });+ const controller = new AbortController();+ const first = fetchRemoteFileToCache(+ id,+ async (dest) => {+ oldTemp = dest;+ await fs.writeFile(dest, 'old');+ },+ vi.fn(),+ controller.signal,+ );+ const firstSettled = first.catch(() => undefined);+ await publishing.promise;+ try {+ controller.abort();+ await firstSettled;+ const result = await fetchRemoteFileToCache(id, (dest) => fs.writeFile(dest, 'new'), vi.fn());+ const returnedContent = await fs.readFile(result, 'utf8');+ release.resolve();+ await cleaned.promise;+ expect(await fs.readFile(result, 'utf8')).toBe(returnedContent);+ } finally {+ release.resolve();+ await cleaned.promise;+ }+});++it('does not start work for an already cancelled caller', async () => {+ const controller = new AbortController();+ controller.abort();+ const executor = vi.fn();+ await expect(fetchRemoteFileToCache(id, executor, vi.fn(), controller.signal)).rejects.toThrow(+ 'FILE_PEER_CANCELLED',+ );+ expect(executor).not.toHaveBeenCalled();+});diff --git a/apps/desktop/src/main/file-browser/remote-file-cache.ts b/apps/desktop/src/main/file-browser/remote-file-cache.tsindex 542bb0b475..33f3e4a983 100644--- a/apps/desktop/src/main/file-browser/remote-file-cache.ts+++ b/apps/desktop/src/main/file-browser/remote-file-cache.ts@@ -17,7 +17,7 @@*/import { createHash, randomUUID } from 'node:crypto';-import { promises as fs } from 'node:fs';+import { promises as fs, renameSync } from 'node:fs';import path from 'node:path';import { app } from 'electron';@@ -50,7 +50,11 @@ export type FetchProgressFn = () => void;/** 取回执行体:把远端文件完整写到 destPath(临时路径),完成返回。 */-export type FetchExecutor = (destPath: string, onProgress: FetchProgressFn, signal?: AbortSignal) => Promise<void>;+export type FetchExecutor = (+ destPath: string,+ onProgress: FetchProgressFn,+ signal?: AbortSignal,+) => Promise<void>;function cacheDir(): string {return path.join(app.getPath('userData'), CACHE_DIR_NAME);@@ -152,23 +156,38 @@ function sanitizeBaseName(name: string): string {return name.replace(/[<>:"/\\|?*\u0000-\u001f]/g, '_').replace(/[. ]+$/, '');}-/** 截短到 maxLen 且**保留扩展名**:缓存副本的应用内预览(xdt-file:// 白名单、+/** 截短到 maxBytes UTF-8 字节且**保留扩展名**:缓存副本的应用内预览(xdt-file:// 白名单、* 图片/视频分派)按缓存文件名的扩展名判定,截断丢了 .png/.mp4 会 415。* 超长"扩展名"(最后一个点离结尾很远)按无扩展名处理,不为它牺牲主干。 */-function shortenKeepExt(name: string, maxLen: number): string {- if (name.length <= maxLen) return name;+function shortenKeepExt(name: string, maxBytes: number): string {+ if (Buffer.byteLength(name, 'utf8') <= maxBytes) return name;+ const truncate = (text: string, budget: number) => {+ let result = '';+ for (const character of text) {+ const bytes = Buffer.byteLength(character, 'utf8');+ if (bytes > budget) break;+ result += character;+ budget -= bytes;+ }+ return result;+ };const ext = path.extname(name);- if (ext.length > 1 && ext.length <= 16) {- return name.slice(0, Math.max(1, maxLen - ext.length)) + ext;+ const extBytes = Buffer.byteLength(ext, 'utf8');+ if (ext.length > 1 && extBytes <= 16) {+ return truncate(name.slice(0, -ext.length), maxBytes - extBytes) + ext;}- return name.slice(0, maxLen);+ return truncate(name, maxBytes);}function cachePathFor(id: RemoteFileIdentity): string {- // 两段式:<路径身份>-<size>-<mtime 取整>-<basename>。版本段变 = 新文件;- // 前缀段稳定 = 断线时可按它找"最近一次成功取回的副本"。+ // Keep the path prefix for offline lookup, but hash the exact version. The v2+ // marker prevents rounded legacy versions from being mistaken for exact hits.const base = shortenKeepExt(sanitizeBaseName(path.basename(id.relPath)) || 'file', 80);- return path.join(cacheDir(), `${prefixHashFor(id)}-${id.size}-${Math.round(id.mtimeMs)}-${base}`);+ const version = createHash('sha256')+ .update(JSON.stringify([id.size, id.mtimeMs]))+ .digest('hex')+ .slice(0, 20);+ return path.join(cacheDir(), `${prefixHashFor(id)}-v2-${version}-${base}`);}function assertCacheOwner(scope: string): void {@@ -259,14 +278,11 @@ export async function fetchRemoteFileToCache(): Promise<string> {const scope = id.scope ?? activeOwnerScopeKey();assertCacheOwner(scope);+ if (signal?.aborted) throw new Error('FILE_PEER_CANCELLED');id = { ...id, scope };- const report: FetchProgressFn = (...args) => {- assertCacheOwner(scope);- onProgress(...args);- };const dest = cachePathFor(id);const existing = inflight.get(dest);- if (existing) {+ if (existing && !existing.controller.signal.aborted) {const consumer = Symbol('remote-file-consumer');existing.consumers.add(consumer);try {@@ -283,10 +299,19 @@ export async function fetchRemoteFileToCache(}const controller = new AbortController();+ const assertActive = () => {+ assertCacheOwner(scope);+ if (controller.signal.aborted) throw new Error('FILE_PEER_CANCELLED');+ };+ const report: FetchProgressFn = (...args) => {+ assertCacheOwner(scope);+ if (!controller.signal.aborted) onProgress(...args);+ };const firstConsumer = Symbol('remote-file-consumer');const run = (async () => {try {const st = await fs.stat(dest);+ assertActive();if (st.size === id.size) {// 命中:touch 更新 LRU 位次,秒回。const now = new Date();@@ -300,51 +325,45 @@ export async function fetchRemoteFileToCache(} catch {// miss}- assertCacheOwner(scope);+ assertActive();await fs.mkdir(cacheDir(), { recursive: true });- const tmp = `${dest}.part`;+ // An abandoned executor can still be unwinding when its replacement starts.+ const tmp = path.join(cacheDir(), `${randomUUID()}.part`);try {- assertCacheOwner(scope);+ assertActive();await executor(tmp, report, controller.signal);- assertCacheOwner(scope);+ assertActive();const got = await fs.stat(tmp);- assertCacheOwner(scope);+ assertActive();if (got.size !== id.size) {// 远端文件在取回途中变化(size 对不上)——废弃,让 caller 报错重试。throw new Error(`fetched size mismatch: got ${got.size}, expect ${id.size}`);}- await fs.rename(tmp, dest);- if (scope !== activeOwnerScopeKey()) await fs.rm(dest, { force: true });- assertCacheOwner(scope);+ // Only the same-directory metadata publication is synchronous: cancellation+ // cannot interleave between the active check and rename and let an abandoned+ // publisher overwrite a replacement. Download/write/stat remain asynchronous.+ assertActive();+ renameSync(tmp, dest);} finally {await fs.rm(tmp, { force: true }).catch(() => undefined);}assertCacheOwner(scope);- // 新版本落地即清同路径旧版本(前缀同、文件名不同):被更新文件的历史- // 副本不再占位等 LRU,断线兜底也只会捞到最新成功副本。- void (async () => {- const prefix = `${prefixHashFor(id)}-`;- const names = await fs.readdir(cacheDir()).catch(() => [] as string[]);- for (const n of names) {- // .part 是并发取回(同路径新版本)的活跃临时文件,删了会让那次- // rename 失败、更新中的文件回落旧内容——只清已完成的旧版本副本。- if (n.endsWith('.part')) continue;- if (n.startsWith(prefix) && path.join(cacheDir(), n) !== dest) {- await fs.rm(path.join(cacheDir(), n), { force: true }).catch(() => undefined);- }- }- await evictLru(dest);- })().catch((err) => log.warn('cache cleanup failed', { error: String(err) }));+ // Other versions may already be in use by another preview. Retain them until+ // the existing capacity-based LRU needs space, regardless of completion order.+ void evictLru(dest).catch((err) => log.warn('cache cleanup failed', { error: String(err) }));return dest;})();const owner: InflightRead = { promise: run, controller, consumers: new Set([firstConsumer]) };inflight.set(dest, owner);- void run.then(() => {- if (inflight.get(dest) === owner) inflight.delete(dest);- }, () => {- if (inflight.get(dest) === owner) inflight.delete(dest);- });+ void run.then(+ () => {+ if (inflight.get(dest) === owner) inflight.delete(dest);+ },+ () => {+ if (inflight.get(dest) === owner) inflight.delete(dest);+ },+ );try {const result = await raceWithAbort(run, signal);assertCacheOwner(scope);