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(auth): 保留在途刷新期间的网络恢复信号

Dash5daa4c92f75d
diff --git a/apps/desktop/src/main/__tests__/authRefreshBackoff.test.ts b/apps/desktop/src/main/__tests__/authRefreshBackoff.test.ts
index a8bcd8f6c6..d46a26e6f2 100644
--- a/apps/desktop/src/main/__tests__/authRefreshBackoff.test.ts
+++ b/apps/desktop/src/main/__tests__/authRefreshBackoff.test.ts
@@ -1,6 +1,121 @@
-import { describe, expect, it } from 'vitest';
+import { readFileSync } from 'node:fs';
+import ts from 'typescript';
+import { describe, expect, it, vi } from 'vitest';
import { AuthRefreshBackoff } from '../authRefreshBackoff';
+// Execute the production admission path with a controlled in-flight network result.
+// This reproduces a relay recovery signal arriving before the old refresh fails,
+// without importing Electron or accessing real credentials.
+const source = ts.createSourceFile(
+ 'authManager.ts',
+ readFileSync(new URL('../authManager.ts', import.meta.url), 'utf8'),
+ ts.ScriptTarget.Latest,
+ true,
+);
+const declaration = source.statements.find(
+ (node): node is ts.FunctionDeclaration =>
+ ts.isFunctionDeclaration(node) && node.name?.text === 'refresh',
+)!;
+const compiled = ts.transpileModule(
+ declaration
+ .getText(source)
+ .replace('export async function refresh(', 'async function refreshUnderTest('),
+ {
+ compilerOptions: { target: ts.ScriptTarget.ES2022 },
+ },
+).outputText;
+
+function recoveryHarness() {
+ const retry = vi.fn<() => Promise<boolean>>().mockResolvedValue(true);
+ const h = new Function(
+ 'AuthRefreshBackoff',
+ 'refresh',
+ `
+ let refreshPromise = null;
+ let authStateEpoch = 1;
+ const refreshBackoff = new AuthRefreshBackoff(() => 1_000_000);
+ const getActiveAppSession = () => ({ mode: 'cloud' });
+ const log = { debug() {} };
+ ${compiled}
+ return { call: refreshUnderTest, backoff: refreshBackoff,
+ setPending(value) { refreshPromise = value; },
+ setEpoch(value) { authStateEpoch = value; } };
+ `,
+ )(AuthRefreshBackoff, retry);
+ let finish!: (value: boolean) => void;
+ h.setPending(
+ new Promise<boolean>((resolve) => {
+ finish = resolve;
+ }),
+ );
+ return {
+ ...h,
+ retry,
+ finish: (value = false) => {
+ h.setPending(null);
+ finish(value);
+ },
+ };
+}
+
+describe('network recovery during an in-flight refresh', () => {
+ it('retries a late network failure once and retains the next failure cooldown', async () => {
+ const h = recoveryHarness();
+ h.retry.mockImplementation(async () => {
+ h.backoff.defer(1, undefined, true);
+ return false;
+ });
+ const ordinary = h.call();
+ const recovery = h.call({ networkRecovered: true });
+ expect(h.retry).not.toHaveBeenCalled();
+ h.backoff.defer(1, undefined, true);
+ h.finish();
+ await expect(ordinary).resolves.toBe(false);
+ await expect(recovery).resolves.toBe(false);
+ expect(h.retry).toHaveBeenCalledExactlyOnceWith();
+ expect(h.backoff.remaining(1)).toBe(60_000);
+ });
+
+ it('coalesces concurrent recovery callers onto the new in-flight refresh', async () => {
+ const h = recoveryHarness();
+ let completeRetry!: (value: boolean) => void;
+ const next = new Promise<boolean>((resolve) => {
+ completeRetry = resolve;
+ });
+ h.retry.mockImplementation(() => {
+ h.setPending(next);
+ return next;
+ });
+ const first = h.call({ networkRecovered: true });
+ const second = h.call({ networkRecovered: true });
+ h.backoff.defer(1, undefined, true);
+ h.finish();
+ await Promise.resolve();
+ expect(h.retry).toHaveBeenCalledExactlyOnceWith();
+ completeRetry(true);
+ await expect(Promise.all([first, second])).resolves.toEqual([true, true]);
+ });
+
+ it.each(['server failure', 'Retry-After', 'owner changed', 'succeeded'])(
+ 'does not retry or clear the deadline when the in-flight refresh %s',
+ async (outcome) => {
+ const h = recoveryHarness();
+ const recovery = h.call({ networkRecovered: true });
+ const epoch = outcome === 'owner changed' ? 2 : 1;
+ h.setEpoch(epoch);
+ const delay = h.backoff.defer(
+ epoch,
+ outcome === 'Retry-After' ? 1_120_000 : undefined,
+ outcome === 'owner changed',
+ );
+ h.finish(outcome === 'succeeded');
+ await expect(recovery).resolves.toBe(outcome === 'succeeded');
+ expect(h.retry).not.toHaveBeenCalled();
+ expect(h.backoff.remaining(epoch)).toBe(delay);
+ },
+ );
+});
+
describe('runtime auth refresh backoff', () => {
it('releases only a transport failure after a real response from the same login generation', () => {
const backoff = new AuthRefreshBackoff(() => 1_000_000);
@@ -14,12 +129,15 @@ describe('runtime auth refresh backoff', () => {
expect(backoff.remaining(1)).toBe(60_000);
});
- it.each([undefined, 1_030_000, 1_120_000])('never bypasses server failure or rate limiting (%s)', retryAt => {
- const backoff = new AuthRefreshBackoff(() => 1_000_000);
- const delay = backoff.defer(1, retryAt);
- backoff.networkRecovered(1);
- expect(backoff.remaining(1)).toBe(delay);
- });
+ it.each([undefined, 1_030_000, 1_120_000])(
+ 'never bypasses server failure or rate limiting (%s)',
+ (retryAt) => {
+ const backoff = new AuthRefreshBackoff(() => 1_000_000);
+ const delay = backoff.defer(1, retryAt);
+ backoff.networkRecovered(1);
+ expect(backoff.remaining(1)).toBe(delay);
+ },
+ );
it('keeps an absolute deadline across two-second explicit calls and resumes at expiry', () => {
let now = 1_000_000;
@@ -46,10 +164,13 @@ describe('runtime auth refresh backoff', () => {
expect(backoff.remaining(2)).toBe(60_000);
});
- it.each([undefined, 0, 999_999, Number.NaN, Number.POSITIVE_INFINITY])('retains the minimum wait for invalid or shorter deadline %s', retryAt => {
- const backoff = new AuthRefreshBackoff(() => 1_000_000);
- expect(backoff.defer(1, retryAt)).toBe(60_000);
- });
+ it.each([undefined, 0, 999_999, Number.NaN, Number.POSITIVE_INFINITY])(
+ 'retains the minimum wait for invalid or shorter deadline %s',
+ (retryAt) => {
+ const backoff = new AuthRefreshBackoff(() => 1_000_000);
+ expect(backoff.defer(1, retryAt)).toBe(60_000);
+ },
+ );
it('clears the failed wait when a successful login or refresh schedules normal renewal', () => {
const backoff = new AuthRefreshBackoff(() => 1_000_000);
diff --git a/apps/desktop/src/main/authManager.ts b/apps/desktop/src/main/authManager.ts
index b1476ed69b..12daf1f97d 100644
--- a/apps/desktop/src/main/authManager.ts
+++ b/apps/desktop/src/main/authManager.ts
@@ -5728,7 +5728,18 @@ export async function refresh(options?: { networkRecovered?: boolean }): Promise
log.debug('runtime refresh skipped in local mode');
return false;
}
- if (refreshPromise !== null) return refreshPromise;
+ if (refreshPromise !== null) {
+ if (!options?.networkRecovered) return refreshPromise;
+ const recoveryEpoch = authStateEpoch;
+ const refreshed = await refreshPromise;
+ if (refreshed || authStateEpoch !== recoveryEpoch) return refreshed;
+ // Another recovery caller may already have started the next single flight.
+ if (refreshPromise !== null) return refreshPromise;
+ if (!refreshBackoff.networkRecovered(recoveryEpoch)) return false;
+ // Consume this hint once, including when the old network failure arrived
+ // after it. A failure of the new attempt must retain its own cooldown.
+ return refresh();
+ }
if (options?.networkRecovered) refreshBackoff.networkRecovered(authStateEpoch);
// Explicit callers (including chat polling and resume) share the same wait
// as the retry timer; skipped calls must not move the deadline forward.
diff --git a/apps/desktop/src/main/authRefreshBackoff.ts b/apps/desktop/src/main/authRefreshBackoff.ts
index 45359c9ff7..0368953aca 100644
--- a/apps/desktop/src/main/authRefreshBackoff.ts
+++ b/apps/desktop/src/main/authRefreshBackoff.ts
@@ -18,8 +18,10 @@ export class AuthRefreshBackoff {
}
/** A real server response proves reachability; interface hints do not. */
- networkRecovered(epoch: number): void {
- if (this.epoch === epoch && this.networkFailure) this.clear();
+ networkRecovered(epoch: number): boolean {
+ if (this.epoch !== epoch || !this.networkFailure) return false;
+ this.clear();
+ return true;
}
clear(): void {
diff --git a/docs/dev-rules/credentials-and-local-storage.md b/docs/dev-rules/credentials-and-local-storage.md
index 5e804dd71e..d9efbaddf2 100644
--- a/docs/dev-rules/credentials-and-local-storage.md
+++ b/docs/dev-rules/credentials-and-local-storage.md
@@ -184,7 +184,9 @@ Desktop 的运行时 refresh 遇到瞬时失败后,主动调用与定时重试
原期限,也不清除凭证。成功续期/登录清除等待,登录代次改变后旧等待不约束新账号。
唯一提前结束等待的情形是:此前失败为无服务端响应的网络错误(status 0),且 relay
随后明确返回鉴权拒绝,证明网络路径已可达。同登录代次的自救可提前续期,仍复用在途
-refresh 与 relay 自救节流;网卡变化提示不能触发该例外,429、Retry-After 和服务端错误
+refresh 与 relay 自救节流。在途 refresh 尚未返回时收到的恢复信号等待其结束;若同代次
+请求随后以网络错误失败,只补一次续期,并发恢复调用仍共享该次请求,新失败保留自己的
+等待期限。网卡变化提示不能触发该例外,429、Retry-After 和服务端错误
仍遵守原期限。续期完成后的立即重连须复验 client、owner 与持有权,不能唤醒旧实例。
冷启动、确定性失效和同机 token 替换恢复继续沿用原有判定。状态只留在进程内存中。
实现见 `main/authRefreshBackoff.ts`、`main/authManager.ts`;回归见