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(model-access): Key 被拒后的自动同步失败时不降级状态(修复 e2e N9)

fmfsaisai073b7fd39bb2
diff --git a/apps/desktop/src/main/model-access/__tests__/credentialsSync.test.ts b/apps/desktop/src/main/model-access/__tests__/credentialsSync.test.ts
index 6d7933b4c2..88c964cc31 100644
--- a/apps/desktop/src/main/model-access/__tests__/credentialsSync.test.ts
+++ b/apps/desktop/src/main/model-access/__tests__/credentialsSync.test.ts
@@ -321,4 +321,127 @@ describe('credentialsSync', () => {
expect(h.sync.getStatus().state).toBe('ok');
});
});
+
+ describe('resyncAfterKeyRejection(Key 被拒后的静默同步)', () => {
+ async function okHarness(overrides: Partial<CredentialsSyncDeps> = {}) {
+ const h = makeHarness(overrides);
+ h.fetchMock.mockResolvedValueOnce({ endpoint: 'https://laxa.test.invalid', apiKey: 'sk-old' });
+ await h.sync.sync();
+ expect(h.sync.getStatus().state).toBe('ok');
+ h.statuses.length = 0;
+ h.fetchMock.mockReset();
+ return h;
+ }
+
+ it.each([
+ ['5xx', () => Promise.reject(serverError('INTERNAL', 500))],
+ ['网络错误', () => Promise.reject(new Error('socket hang up'))],
+ ['payload 不合法', () => Promise.resolve({ endpoint: '', apiKey: '' })],
+ ])('可重试失败(%s)重试用尽后保持 ok,不广播 syncing / failed', async (_label, failure) => {
+ const h = await okHarness();
+ h.fetchMock.mockImplementation(failure as () => Promise<CredentialsPayload>);
+
+ const result = await h.sync.resyncAfterKeyRejection();
+ expect(h.fetchMock).toHaveBeenCalledTimes(3); // 首次 + retryDelaysMs 两次
+ expect(result.state).toBe('ok');
+ expect(h.sync.getStatus().state).toBe('ok');
+ expect(h.statuses).toEqual([]);
+ expect(h.written).toEqual(['sk-old']);
+ });
+
+ it('从 failed 出发的静默失败保持 failed', async () => {
+ const h = makeHarness();
+ h.fetchMock.mockRejectedValue(serverError('INTERNAL', 500));
+ await h.sync.sync();
+ expect(h.sync.getStatus().state).toBe('failed');
+ h.statuses.length = 0;
+
+ const result = await h.sync.resyncAfterKeyRejection();
+ expect(result.state).toBe('failed');
+ expect(h.statuses).toEqual([]);
+ });
+
+ it('拿到新 Key:写入并转 ok,与 sync() 一致(不广播 syncing)', async () => {
+ const h = await okHarness();
+ h.fetchMock.mockResolvedValue({ endpoint: 'https://laxa.test.invalid', apiKey: 'sk-new' });
+
+ const result = await h.sync.resyncAfterKeyRejection();
+ expect(result.state).toBe('ok');
+ expect(h.written).toEqual(['sk-old', 'sk-new']);
+ expect(h.statuses.map((s) => s.state)).toEqual(['ok']);
+ });
+
+ it.each([
+ [503, 'MODEL_ACCESS_DISABLED', 'disabled'],
+ [403, 'ORG_NOT_SUPPORTED', 'unsupported'],
+ ] as const)('服务端 %s 是确定终态,照常转 %s', async (statusCode, code, state) => {
+ const h = await okHarness();
+ h.fetchMock.mockRejectedValue(serverError(code, statusCode));
+
+ const result = await h.sync.resyncAfterKeyRejection();
+ expect(result.state).toBe(state);
+ expect(h.statuses.map((s) => s.state)).toEqual([state]);
+ // 终态后与 sync() 一样不再打服务端。
+ await h.sync.resyncAfterKeyRejection();
+ expect(h.fetchMock).toHaveBeenCalledTimes(1);
+ });
+
+ it('写 key 失败:保持原状态,不转 failed', async () => {
+ let allowWrite = true;
+ const h = await okHarness({
+ writeXdKey: async () => allowWrite,
+ });
+ allowWrite = false;
+ h.fetchMock.mockResolvedValue({ endpoint: 'https://laxa.test.invalid', apiKey: 'sk-new' });
+
+ const result = await h.sync.resyncAfterKeyRejection();
+ expect(result.state).toBe('ok');
+ expect(h.statuses).toEqual([]);
+ });
+
+ it('同世代已有同步在途时复用,不重复请求', async () => {
+ const h = makeHarness();
+ let resolveFetch!: (p: CredentialsPayload) => void;
+ h.fetchMock.mockImplementation(
+ () => new Promise<CredentialsPayload>((resolve) => {
+ resolveFetch = resolve;
+ }),
+ );
+ const first = h.sync.sync();
+ const second = h.sync.resyncAfterKeyRejection();
+ await vi.waitFor(() => expect(h.fetchMock).toHaveBeenCalledTimes(1));
+ resolveFetch({ endpoint: 'https://laxa.test.invalid', apiKey: 'sk-1' });
+ await expect(second).resolves.toMatchObject({ state: 'ok' });
+ await expect(first).resolves.toMatchObject({ state: 'ok' });
+ expect(h.fetchMock).toHaveBeenCalledTimes(1);
+ });
+
+ it('静默同步在途时 sync() 复用它,失败语义回到 sync():仍转 failed', async () => {
+ const h = await okHarness();
+ let rejectFirst!: (e: unknown) => void;
+ h.fetchMock
+ .mockImplementationOnce(
+ () => new Promise<CredentialsPayload>((_resolve, reject) => {
+ rejectFirst = reject;
+ }),
+ )
+ .mockRejectedValue(serverError('INTERNAL', 500));
+ const silent = h.sync.resyncAfterKeyRejection();
+ const loud = h.sync.sync();
+ await vi.waitFor(() => expect(h.fetchMock).toHaveBeenCalledTimes(1));
+ rejectFirst(serverError('INTERNAL', 500));
+ await expect(loud).resolves.toMatchObject({ state: 'failed', errorCode: 'SYNC_FAILED' });
+ await expect(silent).resolves.toMatchObject({ state: 'failed' });
+ expect(h.fetchMock).toHaveBeenCalledTimes(3);
+ });
+
+ it('sync() 原有失败语义不变:仍转 failed', async () => {
+ const h = await okHarness();
+ h.fetchMock.mockRejectedValue(serverError('INTERNAL', 500));
+
+ const result = await h.sync.sync();
+ expect(result).toMatchObject({ state: 'failed', errorCode: 'SYNC_FAILED' });
+ expect(h.statuses.map((s) => s.state)).toEqual(['syncing', 'failed']);
+ });
+ });
});
diff --git a/apps/desktop/src/main/model-access/credentialsSync.ts b/apps/desktop/src/main/model-access/credentialsSync.ts
index 7b4c65cb43..3c9a1b293d 100644
--- a/apps/desktop/src/main/model-access/credentialsSync.ts
+++ b/apps/desktop/src/main/model-access/credentialsSync.ts
@@ -93,6 +93,15 @@ export interface CredentialsSync {
sync(): Promise<ModelAccessStatus>;
/** UI 手动重试:复位终态限制后重新同步。 */
retry(): Promise<ModelAccessStatus>;
+ /**
+ * Key 被网关拒绝后的静默重新同步(gatewayKeyRejection 专用)。只在拿到新凭据或服务端给出
+ * 确定终态(503 disabled / 403 unsupported)时才改状态;不广播 syncing,重试用尽或写 key
+ * 失败都只记 warn、保持原状态。原因:401 可能是误报,凭据接口也可能暂时不可用——这时
+ * 降成 failed 会清空 Cindy AI 模型列表、把辅助模型链和对话都停掉,之后不再有带 Key 的
+ * 请求产生 401,窗口过后也无从再触发,只能等手动重试或重启。
+ * 同世代已有同步在途时复用它;unsupported / disabled 下与 sync() 一样直接返回。
+ */
+ resyncAfterKeyRejection(): Promise<ModelAccessStatus>;
/** 轮换:成功返回新状态;失败抛 CredentialsFetchError 形状(IPC 层映射错误码)。 */
rotate(): Promise<ModelAccessStatus>;
/**
@@ -113,12 +122,22 @@ export interface CredentialsSync {
const DEFAULT_RETRY_DELAYS_MS = [2_000, 8_000];
+/** 一轮同步的失败处理方式;silent = 失败不降级状态(见 resyncAfterKeyRejection)。 */
+interface SyncMode {
+ silent: boolean;
+}
+
export function createCredentialsSync(deps: CredentialsSyncDeps): CredentialsSync {
const sleep = deps.sleep ?? ((ms: number) => new Promise((r) => setTimeout(r, ms)));
const retryDelays = deps.retryDelaysMs ?? DEFAULT_RETRY_DELAYS_MS;
let status: ModelAccessStatus = snapshot('idle');
let inflight: Promise<ModelAccessStatus> | null = null;
+ /**
+ * 在途同步的失败处理方式。静默同步(resyncAfterKeyRejection)在途时被 sync() / retry()
+ * 复用,会改回非静默,保证这两个入口的失败语义不变。
+ */
+ let inflightMode: SyncMode = { silent: false };
/**
* 认证世代号:登出、换账号或同账号跨区时自增。所有写盘(key/endpoint/状态)
* 都以发起时捕获的世代为闸——旧身份的在途请求在世代变更后一律作废。
@@ -160,7 +179,10 @@ export function createCredentialsSync(deps: CredentialsSyncDeps): CredentialsSyn
}
/** 单次拉取 + 落盘。返回终局状态;'retryable' 可退避重试;'stale' = 世代已过期。 */
- async function attemptOnce(myEpoch: number): Promise<ModelAccessStatus | 'retryable' | 'stale'> {
+ async function attemptOnce(
+ myEpoch: number,
+ mode: SyncMode,
+ ): Promise<ModelAccessStatus | 'retryable' | 'stale'> {
let payload: CredentialsPayload;
try {
payload = await deps.fetchCredentials();
@@ -183,13 +205,14 @@ export function createCredentialsSync(deps: CredentialsSyncDeps): CredentialsSyn
deps.log?.warn('model-access credentials response invalid (empty key / bad endpoint), kept local');
return 'retryable';
}
- return applyPayload(payload, myEpoch);
+ return applyPayload(payload, myEpoch, mode);
}
/** 下发结果落盘(sync 与 rotate 共用,世代闸)。值未变不写 key,不触发 codex 重启。 */
async function applyPayload(
payload: CredentialsPayload,
myEpoch: number,
+ mode: SyncMode = { silent: false },
): Promise<ModelAccessStatus> {
if (myEpoch !== epoch) return status;
const current = deps.readXdKey();
@@ -197,6 +220,11 @@ export function createCredentialsSync(deps: CredentialsSyncDeps): CredentialsSyn
const ok = await deps.writeXdKey(payload.apiKey);
if (myEpoch !== epoch) return status;
if (!ok) {
+ if (mode.silent) {
+ // 静默同步:保持原状态,下一次 401 窗口过后还能再试。
+ deps.log?.warn('model-access key write failed after key rejection, keeping current status');
+ return status;
+ }
deps.log?.warn('model-access key write failed (safeStorage unavailable?)');
return setStatus('failed', 'SAFE_STORAGE_UNAVAILABLE');
}
@@ -205,14 +233,18 @@ export function createCredentialsSync(deps: CredentialsSyncDeps): CredentialsSyn
return setStatus('ok');
}
- async function runSync(myEpoch: number): Promise<ModelAccessStatus> {
+ async function runSync(myEpoch: number, mode: SyncMode): Promise<ModelAccessStatus> {
if (myEpoch !== epoch) return status;
- setStatus('syncing');
+ if (!mode.silent) setStatus('syncing');
for (let attempt = 0; ; attempt++) {
- const result = await attemptOnce(myEpoch);
+ const result = await attemptOnce(myEpoch, mode);
if (result === 'stale' || myEpoch !== epoch) return status; // 登出/换账号,放弃本轮
if (result !== 'retryable') return result;
if (attempt >= retryDelays.length) {
+ if (mode.silent) {
+ deps.log?.warn('model-access re-sync after key rejection failed, keeping current status');
+ return status;
+ }
return setStatusIfFresh(myEpoch, 'failed', 'SYNC_FAILED');
}
await sleep(retryDelays[attempt]);
@@ -220,13 +252,18 @@ export function createCredentialsSync(deps: CredentialsSyncDeps): CredentialsSyn
}
}
- function startSync(): Promise<ModelAccessStatus> {
+ function startSync(silent = false): Promise<ModelAccessStatus> {
// 只复用**同世代**的在途请求;旧世代 inflight 会因世代闸自行作废,
// 这里直接为当前账号发起新一轮(短暂并行无害,旧轮零写盘)。
- if (inflight && inflightEpoch === epoch) return inflight;
+ if (inflight && inflightEpoch === epoch) {
+ if (!silent) inflightMode.silent = false;
+ return inflight;
+ }
const myEpoch = epoch;
inflightEpoch = myEpoch;
- const run = runSync(myEpoch).finally(() => {
+ const mode: SyncMode = { silent };
+ inflightMode = mode;
+ const run = runSync(myEpoch, mode).finally(() => {
if (inflight === run) inflight = null;
});
inflight = run;
@@ -252,6 +289,13 @@ export function createCredentialsSync(deps: CredentialsSyncDeps): CredentialsSyn
return startSync();
},
+ resyncAfterKeyRejection() {
+ if (status.state === 'unsupported' || status.state === 'disabled') {
+ return Promise.resolve(status);
+ }
+ return startSync(true);
+ },
+
async rotate() {
// rotate 不与 sync 合并:等待在途同步完成后执行,语义上必须真的轮换。
if (inflight) await inflight.catch(() => undefined);
diff --git a/apps/desktop/src/main/model-access/gatewayKeyRejection.ts b/apps/desktop/src/main/model-access/gatewayKeyRejection.ts
index 5b31f2ee89..f58d54d92f 100644
--- a/apps/desktop/src/main/model-access/gatewayKeyRejection.ts
+++ b/apps/desktop/src/main/model-access/gatewayKeyRejection.ts
@@ -25,8 +25,10 @@ import { getModelAccessCredentialsStore } from './credentialsStore.js';
* 重试后以 failed 状态结束(不 reject),服务端也可能在网关鉴权缓存窗口内原样返回这把稍后
* 才被撤销的 Key。永久标记会让这把 Key 之后的 401 一律被忽略,直到重启;窗口过后再允许
* 触发一次即可自行恢复。窗口内不重复,则不会对着挂掉的服务端或误报的 401 反复请求。
- * 同步用 `sync()` 而不是 `retry()`:它尊重 unsupported / disabled 终态,自带 single-flight
- * 与内部重试;失败沿用现有同步表现,这里不新增提示。
+ * 同步用 `credentialsSync.resyncAfterKeyRejection()`:与 `sync()` 一样尊重 unsupported /
+ * disabled 终态、复用同世代在途同步、带内部重试;但不广播 syncing,失败不降级状态、不清空
+ * 模型列表(401 可能误报、凭据接口可能暂时不可用,降级会停掉 Cindy AI 且不再有请求触发
+ * 窗口后的重试)。这里不新增提示。
*
* 工厂函数的依赖全部注入,便于单测。进程内单例的默认依赖在本文件组装,只有凭据同步
* (`requestSync`)由 model-access/index.ts 在 initModelAccess 时经
@@ -44,7 +46,7 @@ export interface GatewayKeyRejectionDeps {
getCredentialSource(): ModelAccessCredentialSource | null;
/** 本机当前保存的 Cindy AI Key(providerSecretStore 'xd')。 */
readCurrentKey(): string | null;
- /** 触发一次凭据同步(credentialsSync.sync())。 */
+ /** 触发一次凭据同步(credentialsSync.resyncAfterKeyRejection())。 */
requestSync(): Promise<unknown>;
log?: {
info(message: string): void;
diff --git a/apps/desktop/src/main/model-access/index.ts b/apps/desktop/src/main/model-access/index.ts
index 9d15e5567e..2578ee427a 100644
--- a/apps/desktop/src/main/model-access/index.ts
+++ b/apps/desktop/src/main/model-access/index.ts
@@ -512,7 +512,8 @@ function mapServerError(err: unknown): never {
export function initModelAccess(): void {
const sync = getSync();
// 主进程各调用方遇到 Cindy 网关 401 时经此重新拉取凭据(服务端会探测并换发失效 Key)。
- installCindyGatewayKeyRejectionReporter(() => getSync().sync());
+ // 用静默同步:失败不降级状态、不清空模型列表(见 credentialsSync.resyncAfterKeyRejection)。
+ installCindyGatewayKeyRejectionReporter(() => getSync().resyncAfterKeyRejection());
const byok = createByokRuntime(
broadcastReferenceModelPricing,
createByokCache(byokSnapshotSecretIo),