Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

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.ts
index 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', async
const 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', async
secondController.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.ts
new file mode 100644
index 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.ts
index 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);