Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
fix(desktop): 释放失败清单与更新说明的原生响应资源 (#5438)
FicoWangb900eb565e3f
diff --git a/apps/desktop/src/main/__tests__/cdnResponseLifecycle.test.ts b/apps/desktop/src/main/__tests__/cdnResponseLifecycle.test.tsnew file mode 100644index 0000000000..eaa65a3848--- /dev/null+++ b/apps/desktop/src/main/__tests__/cdnResponseLifecycle.test.ts@@ -0,0 +1,165 @@+import { EventEmitter } from 'node:events';+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';++const requestMock = vi.hoisted(() => vi.fn());+vi.mock('electron', () => ({ app: { isPackaged: true }, net: { request: requestMock } }));+vi.mock('../logger', () => ({+ createLogger: () => ({ info: vi.fn(), warn: vi.fn(), error: vi.fn() }),+}));+vi.mock('../canaryFlagStore', () => ({ read: () => false }));+vi.mock('../updateChannelStore', () => ({ isBetaChannelEnabled: () => false }));+vi.mock('../clientEndpointsService', () => ({ getClientEndpoint: () => 'https://cdn.example.test' }));++// Model response and request lifetimes separately: Electron's writable request+// can emit close before response data/end. Only response termination owns the body.+function transport(action: (request: EventEmitter, response: EventEmitter) => void) {+ const requests: Array<EventEmitter & { end: ReturnType<typeof vi.fn>; abort: ReturnType<typeof vi.fn> }> = [];+ const responses: Array<EventEmitter & { statusCode: number }> = [];+ requestMock.mockImplementation(() => {+ const response = Object.assign(new EventEmitter(), { statusCode: 200 });+ const request = Object.assign(new EventEmitter(), {+ end: vi.fn(() => action(request, response)),+ abort: vi.fn(() => {+ // Exercise re-entrant cleanup and error listeners on discarded bodies.+ request.emit('error', new Error('aborted'));+ if (response.listenerCount('error')) response.emit('error', new Error('aborted body'));+ response.emit('close');+ }),+ });+ requests.push(request);+ responses.push(response);+ return request;+ });+ return { requests, responses };+}++beforeEach(() => {+ vi.resetModules();+ requestMock.mockReset();+ vi.useFakeTimers();+});+afterEach(() => vi.useRealTimers());++describe.each(['manifest', 'release'] as const)('%s response lifecycle', (consumer) => {+ async function start() {+ if (consumer === 'manifest') {+ const { fetchManifest } = await import('../manifestService');+ return { call: (signal?: AbortSignal) => fetchManifest(100, signal), good: '{"app":{"version":"1.0.0"}}' };+ }+ const { fetchReleaseNotesIndex } = await import('../releaseNotesService');+ return { call: fetchReleaseNotesIndex, good: '["1.0.0"]' };+ }++ it.each([403, 404, 429, 500, 503])('aborts HTTP %s without waiting for a body or changing retry classification', async (status) => {+ const { call } = await start();+ const { requests, responses } = transport((request, response) => {+ Object.assign(response, { statusCode: status });+ request.emit('response', response);+ });+ await expect(call()).resolves.toBeNull();+ expect(requests).toHaveLength(1);+ expect(requests[0].abort).toHaveBeenCalledTimes(1);+ // Late errors must remain handled after the HTTP result has settled.+ expect(() => responses[0].emit('error', new Error('late error'))).not.toThrow();+ expect(vi.getTimerCount()).toBe(0);+ });++ it.each(['no headers', 'unfinished 200', 'stream error', 'early response close', 'network error', 'end throws'])('releases %s and settles within the existing retry budget', async (scenario) => {+ const { call } = await start();+ const { requests } = transport((request, response) => {+ if (scenario === 'end throws') throw new Error('synchronous end failure');+ if (scenario === 'network error') { request.emit('error', new Error('offline')); return; }+ if (scenario === 'no headers') return;+ request.emit('response', response);+ response.emit('data', Buffer.from('{'));+ if (scenario === 'stream error') response.emit('error', new Error('broken stream'));+ if (scenario === 'early response close') response.emit('close');+ });+ const pending = call();+ await vi.runAllTimersAsync();+ await expect(pending).resolves.toBeNull();+ expect(requests).toHaveLength(consumer === 'manifest' ? 1 : 4);+ for (const request of requests) expect(request.abort).toHaveBeenCalledTimes(1);+ expect(vi.getTimerCount()).toBe(0);+ });++ it.each(['', '{invalid'])('fully consumes invalid JSON %j without retrying', async (body) => {+ const { call } = await start();+ const { requests } = transport((request, response) => {+ request.emit('response', response);+ response.emit('data', Buffer.from(body));+ response.emit('end');+ response.emit('close');+ });+ await expect(call()).resolves.toBeNull();+ expect(requests).toHaveLength(1);+ expect(requests[0].abort).not.toHaveBeenCalled();+ expect(vi.getTimerCount()).toBe(0);+ });++ it('waits for response end despite an earlier writable request close', async () => {+ const { call, good } = await start();+ const { requests, responses } = transport((request, response) => {+ request.emit('close');+ request.emit('response', response);+ response.emit('data', Buffer.from(good));+ });+ const settled = vi.fn();+ const pending = call().then(settled);+ await Promise.resolve();+ expect(settled).not.toHaveBeenCalled();+ expect(vi.getTimerCount()).toBe(1);+ responses[0].emit('end');+ responses[0].emit('close');+ await pending;+ expect(settled).toHaveBeenCalledTimes(1);+ expect(settled.mock.calls[0][0]).not.toBeNull();+ expect(requests[0].abort).not.toHaveBeenCalled();+ expect(vi.getTimerCount()).toBe(0);+ });++ it('aborts oversized 200 bodies and ignores later data/end', async () => {+ const { call } = await start();+ const { requests } = transport((request, response) => {+ request.emit('response', response);+ const chunk = Buffer.alloc(1024 * 1024, ' ');+ for (let i = 0; i < 9; i++) response.emit('data', chunk);+ response.emit('end');+ });+ await expect(call()).resolves.toBeNull();+ expect(requests).toHaveLength(1);+ expect(requests[0].abort).toHaveBeenCalledTimes(1);+ expect(vi.getTimerCount()).toBe(0);+ });+});++describe('manifest caller cancellation', () => {+ it.each(['before creation', 'during creation', 'before headers', 'after headers'])('handles cancellation %s', async (when) => {+ const { fetchManifest, getCachedManifest } = await import('../manifestService');+ const controller = new AbortController();+ const remove = vi.spyOn(controller.signal, 'removeEventListener');+ const { requests, responses } = transport((request, response) => {+ if (when === 'after headers') request.emit('response', response);+ });+ if (when === 'before creation') controller.abort();+ if (when === 'during creation') {+ const create = requestMock.getMockImplementation()!;+ requestMock.mockImplementation(() => { controller.abort(); return create(); });+ }+ const pending = fetchManifest(100, controller.signal);+ controller.abort();+ await expect(pending).resolves.toBeNull();+ if (when === 'before creation') expect(requestMock).not.toHaveBeenCalled();+ else {+ expect(requests[0].abort).toHaveBeenCalledTimes(1);+ expect(remove).toHaveBeenCalled();+ // A late response cannot resurrect a completed request or update cache.+ requests[0].emit('response', responses[0]);+ responses[0].emit('data', Buffer.from('{"app":{"version":"9.0.0"}}'));+ responses[0].emit('end');+ expect(getCachedManifest()).toBeNull();+ if (when === 'during creation') expect(requests[0].end).not.toHaveBeenCalled();+ }+ expect(vi.getTimerCount()).toBe(0);+ });+});diff --git a/apps/desktop/src/main/__tests__/clientEndpointsService.test.ts b/apps/desktop/src/main/__tests__/clientEndpointsService.test.tsindex bd3815e8ab..357bd92413 100644--- a/apps/desktop/src/main/__tests__/clientEndpointsService.test.ts+++ b/apps/desktop/src/main/__tests__/clientEndpointsService.test.ts@@ -1508,6 +1508,24 @@ describe('netlog 产物事后核对(verifyEndpointNetLogCapture)', () => {});describe('getter / IPC', () => {+ it('aborts a non-200 endpoint response instead of draining without a deadline', async () => {+ resetClientEndpointsForTest(TEST_CLIENT_ENDPOINTS, {+ buildRegion: 'cn',+ realmManifestBaseUrls: {+ cn: 'https://manifest.cn.example.com/app',+ global: 'https://manifest.global.example.com/app',+ },+ });+ const response = Object.assign(new EventEmitter(), { statusCode: 404 });+ const request = Object.assign(new EventEmitter(), {+ end: vi.fn(() => request.emit('response', response)),+ abort: vi.fn(() => response.emit('error', new Error('cancelled'))),+ });+ netRequest.mockReturnValueOnce(request);+ await expect(loadClientEndpointsForRealm('global')).rejects.toThrow('http-404');+ expect(request.abort).toHaveBeenCalledTimes(1);+ });+it('默认不是离线缓存启动', () => {expect(isUsingCachedClientEndpoints()).toBe(false);});diff --git a/apps/desktop/src/main/__tests__/manifestService.test.ts b/apps/desktop/src/main/__tests__/manifestService.test.tsindex 3d7113255b..0904fdf4e4 100644--- a/apps/desktop/src/main/__tests__/manifestService.test.ts+++ b/apps/desktop/src/main/__tests__/manifestService.test.ts@@ -107,6 +107,20 @@ describe('manifestService cache channel identity', () => {expect(String(netRequest.mock.calls[0]?.[0])).not.toContain('-beta.json');});+ it('aborts an unread non-200 response before removing cancellation ownership', async () => {+ const request = Object.assign(new EventEmitter(), { end: vi.fn(), abort: vi.fn() });+ const response = Object.assign(new EventEmitter(), { statusCode: 404 });+ netRequest.mockReturnValueOnce(request);+ const controller = new AbortController();+ const service = await import('../manifestService');+ const pending = service.fetchManifest(1_000, controller.signal);+ request.emit('response', response);+ await expect(pending).resolves.toBeNull();+ expect(request.abort).toHaveBeenCalledTimes(1);+ controller.abort();+ expect(request.abort).toHaveBeenCalledTimes(1);+ });+it('does not cache a fetch that finishes after the shared channel changes', async () => {mockManifestResponse(RELEASE_MANIFEST, () => {isBetaChannelEnabled.mockReturnValue(true);diff --git a/apps/desktop/src/main/__tests__/releaseNotesService.test.ts b/apps/desktop/src/main/__tests__/releaseNotesService.test.tsindex 5b0204de16..1c9ee56b0d 100644--- a/apps/desktop/src/main/__tests__/releaseNotesService.test.ts+++ b/apps/desktop/src/main/__tests__/releaseNotesService.test.ts@@ -234,6 +234,7 @@ describe('releaseNotesService', () => {const notes = await promise;expect(notes).toBeNull();expect(requestMock).toHaveBeenCalledTimes(1);+ expect(req.abort).toHaveBeenCalledTimes(1);});it('全部重试耗尽后返回 null', async () => {diff --git a/apps/desktop/src/main/clientEndpointsService.ts b/apps/desktop/src/main/clientEndpointsService.tsindex 659b577ca2..6672bf7caa 100644--- a/apps/desktop/src/main/clientEndpointsService.ts+++ b/apps/desktop/src/main/clientEndpointsService.ts@@ -237,18 +237,19 @@ function fetchTextViaNet(url: string, timeoutMs: number): Promise<ManifestFetchR}, timeoutMs);request.on('response', (response) => {+ response.on('error', (err) =>+ finish({ ok: false, detail: describeFetchError(err), raw: rawFetchError(err) }, timeout),+ );if (response.statusCode !== 200) {- response.on('data', () => {});finish({ ok: false, detail: `http-${response.statusCode}` }, timeout);+ // A discarded error body may never end; don't drain without a timeout.+ request.abort();return;}response.on('data', (chunk) => {body += chunk.toString();});response.on('end', () => finish({ ok: true, text: body }, timeout));- response.on('error', (err) =>- finish({ ok: false, detail: describeFetchError(err), raw: rawFetchError(err) }, timeout),- );});request.on('error', (err) =>finish({ ok: false, detail: describeFetchError(err), raw: rawFetchError(err) }, timeout),diff --git a/apps/desktop/src/main/maker-host/__tests__/providerCatalogRealmReload.test.ts b/apps/desktop/src/main/maker-host/__tests__/providerCatalogRealmReload.test.tsindex 590c70ed33..a71543a4df 100644--- a/apps/desktop/src/main/maker-host/__tests__/providerCatalogRealmReload.test.ts+++ b/apps/desktop/src/main/maker-host/__tests__/providerCatalogRealmReload.test.ts@@ -1,4 +1,5 @@import { randomUUID } from 'node:crypto';+import { EventEmitter } from 'node:events';import { promises as fsp } from 'node:fs';import os from 'node:os';import path from 'node:path';@@ -30,12 +31,14 @@ const h = vi.hoisted(() => ({getGrokAccessToken: vi.fn(),recoverGrokAuthAfterRejection: vi.fn(),warn: vi.fn(),+ request: vi.fn(),+ catalogIo: null as Parameters<typeof import('@cindy/model-providers').loadCatalog>[1] | null,}));vi.mock('electron', () => ({app: { getPath: () => os.tmpdir() },BrowserWindow: { getAllWindows: () => [] },- net: { request: vi.fn() },+ net: { request: h.request },}));vi.mock('@cindy/model-providers', async (importOriginal) => {@@ -43,8 +46,13 @@ vi.mock('@cindy/model-providers', async (importOriginal) => {return {...actual,loadCatalog: vi.fn(- (source: Record<string, unknown>, _io: unknown, onResolved?: (result: unknown) => void) =>+ (+ source: Record<string, unknown>,+ io: Parameters<typeof import('@cindy/model-providers').loadCatalog>[1],+ onResolved?: (result: unknown) => void,+ ) =>new Promise((resolve) => {+ h.catalogIo = io;h.loads.push({source,resolve: (@@ -1312,4 +1320,21 @@ describe('provider catalog realm reload', () => {else process.env.XDT_DISABLE_MODELS_FETCH = savedForceOff;}});++ it('aborts a non-200 catalog body before dropping its timeout', async () => {+ if (!h.catalogIo) {+ const loading = ensureActiveCatalogLoaded();+ h.loads.at(-1)!.resolve(BUNDLED_CATALOG);+ await loading;+ }+ const response = Object.assign(new EventEmitter(), { statusCode: 404 });+ const request = Object.assign(new EventEmitter(), {+ setHeader: vi.fn(),+ end: vi.fn(() => request.emit('response', response)),+ abort: vi.fn(() => response.emit('error', new Error('cancelled'))),+ });+ h.request.mockReturnValueOnce(request);+ await expect(h.catalogIo!.fetchText!('https://catalog.example.test', 100)).rejects.toThrow('HTTP 404');+ expect(request.abort).toHaveBeenCalledTimes(1);+ });});diff --git a/apps/desktop/src/main/maker-host/createDesktopProviderService.ts b/apps/desktop/src/main/maker-host/createDesktopProviderService.tsindex 4d2623da4b..c928106960 100644--- a/apps/desktop/src/main/maker-host/createDesktopProviderService.ts+++ b/apps/desktop/src/main/maker-host/createDesktopProviderService.ts@@ -163,10 +163,15 @@ function fetchText(url: string, timeoutMs: number): Promise<string> {}, timeoutMs);request.on('response', (response) => {+ response.on('error', (err) => {+ clearTimeout(timer);+ settle(() => reject(err));+ });if (response.statusCode !== 200) {clearTimeout(timer);- response.on('data', () => {});settle(() => reject(new Error(`catalog fetch HTTP ${response.statusCode}`)));+ // No error body is needed; draining after clearing the timer can hang.+ request.abort();return;}response.on('data', (chunk) => {@@ -176,10 +181,6 @@ function fetchText(url: string, timeoutMs: number): Promise<string> {clearTimeout(timer);settle(() => resolve(body));});- response.on('error', (err) => {- clearTimeout(timer);- settle(() => reject(err));- });});request.on('error', (err) => {clearTimeout(timer);diff --git a/apps/desktop/src/main/manifestService.ts b/apps/desktop/src/main/manifestService.tsindex a1c019a22d..79a2c9dca8 100644--- a/apps/desktop/src/main/manifestService.ts+++ b/apps/desktop/src/main/manifestService.ts@@ -100,6 +100,8 @@ export interface Manifest {// ── Constants ──────────────────────────────────────────────────────────────const REQUEST_TIMEOUT_MS = 30_000;+// Metadata only: bound accumulation even when a server keeps streaming a 200.+const MAX_RESPONSE_BYTES = 8 * 1024 * 1024;// ── State ──────────────────────────────────────────────────────────────────@@ -179,30 +181,50 @@ export async function fetchManifest(try {const request = net.request(url);let body = '';+ let bodyBytes = 0;let settled = false;- let timeout: ReturnType<typeof setTimeout> | undefined;+ let aborted = false;const finish = (value: Manifest | null, abortRequest = false): void => {- if (settled) return;- settled = true;- if (timeout) clearTimeout(timeout);- signal?.removeEventListener('abort', onAbort);- if (abortRequest) request.abort();- resolve(value);+ if (!settled) {+ settled = true;+ if (timeout) clearTimeout(timeout);+ signal?.removeEventListener('abort', onAbort);+ resolve(value);+ }+ // Promise settlement must not prevent late response/error cleanup.+ if (abortRequest && !aborted) {+ aborted = true;+ request.abort();+ }};const onAbort = (): void => finish(null, true);+ const timeout = setTimeout(() => finish(null, true), timeoutMs ?? REQUEST_TIMEOUT_MS);signal?.addEventListener('abort', onAbort, { once: true });- timeout = setTimeout(() => finish(null, true), timeoutMs ?? REQUEST_TIMEOUT_MS);-request.on('response', (response) => {+ // Keep an error listener even on responses discarded at the headers.+ response.on('error', () => finish(null, true));+ response.on('aborted', () => finish(null, true));+ if (settled) {+ finish(null, true);+ return;+ }if (response.statusCode !== 200) {log.info('HTTP %d for %s', response.statusCode, url);- finish(null);+ // Unread Electron responses retain the native loader and data pipe.+ finish(null, true);return;}response.on('data', (chunk) => {+ if (settled) return;+ bodyBytes += Buffer.byteLength(chunk);+ if (bodyBytes > MAX_RESPONSE_BYTES) {+ body = '';+ finish(null, true);+ return;+ }body += chunk.toString();});response.on('end', () => {@@ -226,12 +248,16 @@ export async function fetchManifest(finish(null);}});- response.on('error', () => finish(null));});- request.on('error', () => finish(null));+ request.on('error', () => finish(null, true));try {+ // A signal can be cancelled while the request is being constructed.+ if (signal?.aborted) {+ onAbort();+ return;+ }request.end();} catch {finish(null, true);@@ -310,7 +336,6 @@ export function probeBetaManifest(timeoutMs = 8_000): Promise<boolean> {const request = net.request(url);let body = '';let settled = false;- let timeout: ReturnType<typeof setTimeout> | undefined;const finish = (value: boolean, abortRequest = false): void => {if (settled) return;settled = true;@@ -318,7 +343,7 @@ export function probeBetaManifest(timeoutMs = 8_000): Promise<boolean> {if (abortRequest) request.abort();resolve(value);};- timeout = setTimeout(() => finish(false, true), timeoutMs);+ const timeout = setTimeout(() => finish(false, true), timeoutMs);request.on('response', (response) => {if (response.statusCode !== 200) {response.on('data', () => {});diff --git a/apps/desktop/src/main/releaseNotesService.ts b/apps/desktop/src/main/releaseNotesService.tsindex a8c1389946..10088e4851 100644--- a/apps/desktop/src/main/releaseNotesService.ts+++ b/apps/desktop/src/main/releaseNotesService.ts@@ -45,6 +45,7 @@ const log = createLogger('releaseNotesService');// ── Constants ──────────────────────────────────────────────────────────────const REQUEST_TIMEOUT_MS = 15_000;+const MAX_RESPONSE_BYTES = 8 * 1024 * 1024;const MAX_RETRIES = 3;const RETRY_BASE_DELAY_MS = 1_000;@@ -81,61 +82,77 @@ function fetchCdnJsonOnce<T>(url: string): Promise<FetchAttempt<T>> {const request = net.request(url);const decoder = new StringDecoder('utf8');let body = '';+ let bodyBytes = 0;let settled = false;+ let aborted = false;- const timeout = setTimeout(() => {+ const finish = (value: FetchAttempt<T>, abortRequest = false): void => {if (!settled) {settled = true;+ if (timeout) clearTimeout(timeout);+ resolve(value);+ }+ // Resource cleanup is independent of settling the business result.+ if (abortRequest && !aborted) {+ aborted = true;request.abort();- log.info('Timeout: %s', url);- resolve({ ok: false, retryable: true });}+ };+ const timeout = setTimeout(() => {+ log.info('Timeout: %s', url);+ finish({ ok: false, retryable: true }, true);}, REQUEST_TIMEOUT_MS);request.on('response', (response) => {+ response.on('error', (err) => {+ log.error('Response error for %s:', url, err);+ finish({ ok: false, retryable: true }, true);+ });+ response.on('aborted', () => finish({ ok: false, retryable: true }, true));+ if (settled) {+ finish({ ok: false, retryable: true }, true);+ return;+ }if (response.statusCode !== 200) {log.info('HTTP %d for %s', response.statusCode, url);- clearTimeout(timeout);- settled = true;- resolve({ ok: false, retryable: false });+ // No error body is needed; don't leave an unread native loader alive.+ finish({ ok: false, retryable: false }, true);return;}response.on('data', (chunk) => {+ if (settled) return;+ bodyBytes += Buffer.byteLength(chunk);+ if (bodyBytes > MAX_RESPONSE_BYTES) {+ body = '';+ finish({ ok: false, retryable: false }, true);+ return;+ }body += decoder.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));});response.on('end', () => {- clearTimeout(timeout);if (settled) return;- settled = true;try {body += decoder.end();- resolve({ ok: true, data: JSON.parse(body) as T });+ finish({ ok: true, data: JSON.parse(body) as T });} catch (err) {log.error('JSON parse failed for %s:', url, err);- resolve({ ok: false, retryable: false });- }- });- response.on('error', (err) => {- log.error('Response error for %s:', url, err);- clearTimeout(timeout);- if (!settled) {- settled = true;- resolve({ ok: false, retryable: true });+ finish({ ok: false, retryable: false });}});});request.on('error', (err) => {log.error('Request error for %s:', url, err);- clearTimeout(timeout);- if (!settled) {- settled = true;- resolve({ ok: false, retryable: true });- }+ finish({ ok: false, retryable: true }, true);});- request.end();+ try {+ request.end();+ } catch (err) {+ log.error('Request start failed for %s:', url, err);+ finish({ ok: false, retryable: true }, true);+ }} catch (err) {log.error('Unexpected error for %s:', url, err);resolve({ ok: false, retryable: true });diff --git a/apps/desktop/src/renderer/components/layout/__tests__/WallpaperVideo.test.tsx b/apps/desktop/src/renderer/components/layout/__tests__/WallpaperVideo.test.tsxindex d3a28c3cbf..d5baf26ad8 100644--- a/apps/desktop/src/renderer/components/layout/__tests__/WallpaperVideo.test.tsx+++ b/apps/desktop/src/renderer/components/layout/__tests__/WallpaperVideo.test.tsx@@ -215,7 +215,12 @@ describe('dynamic wallpaper lifecycle', () => {fireEvent.playing(standard);state.tier = 'hd';rerender(<WallpaperVideo wallpaperId="cindy-window" motion="dynamic" />);- await waitFor(() => expect(document.querySelector('video')!.src).toContain('-hd.mp4'));+ // A new DOM node can precede passive cleanup of the old decoder. Wait for+ // both lifecycle obligations, not just the mutation observer's DOM signal.+ await waitFor(() => {+ expect(document.querySelector('video')!.src).toContain('-hd.mp4');+ expect(standard.getAttribute('src')).toBeNull();+ });const hd = document.querySelector('video')!;expect(hd.src).toContain('cindy-window-hd.mp4');expect(document.querySelectorAll('video')).toHaveLength(1);