@agentunion/fastaun 0.5.35 → 0.5.37

package/dist/client.js

@@ -231,9 +231,32 @@ function clampReconnectDelayMs(value, fallback, upper = RECONNECT_MAX_BASE_DELAY
     return Math.min(Math.max(ms, RECONNECT_MIN_BASE_DELAY_MS), upper);
 }
 function reconnectSleepDelayMs(baseDelay, maxBaseDelay) {
-    // 抖动只随当前退避基数增长，并限制在 maxBaseDelay 内。
-    const jitterLimit = Math.min(Math.max(baseDelay, 0), Math.max(maxBaseDelay - baseDelay, 0));
-    return baseDelay + Math.random() * jitterLimit;
+    return Math.max(1, Math.random() * Math.min(baseDelay, maxBaseDelay));
+}
+const reconnectSlots = new Map();
+async function acquireReconnectSlot(aid, wait, pause) {
+    const issuer = aid.slice(aid.indexOf('.') + 1).toLowerCase();
+    let slots = reconnectSlots.get(issuer);
+    if (!slots) {
+        slots = { active: new Set(), next: 0 };
+        reconnectSlots.set(issuer, slots);
+    }
+    while (slots.active.size >= 2)
+        await wait(Promise.race(slots.active));
+    let done;
+    const ticket = new Promise(resolve => { done = resolve; });
+    slots.active.add(ticket);
+    const release = () => { slots.active.delete(ticket); done(); };
+    const delay = Math.min(500, Math.max(0, slots.next - Date.now()));
+    slots.next = Date.now() + delay + 250 + Math.random() * 250;
+    try {
+        await pause(delay);
+        return release;
+    }
+    catch (error) {
+        release();
+        throw error;
+    }
 }
 /** peer 证书缓存 TTL（1 小时） */
 const PEER_CERT_CACHE_TTL = 3600;
@@ -743,7 +766,7 @@ export class AUNClient {
             if (current())
                 this._credentialRenewalTimer = setTimeout(() => { void scan(); }, 60_000);
         };
-        void scan();
+        this._credentialRenewalTimer = setTimeout(() => { void scan(); }, 30_000 + Math.random() * 30_000);
     }
     _stopCredentialRenewal() {
         this._credentialRenewalAbort?.abort();
@@ -1415,25 +1438,30 @@ export class AUNClient {
         const observation = { root: manager.root, etag: observedEtag, version: Number(record?.observation_version ?? 0), content_hash: typeof record?.content === 'string' ? ownershipSha256(record.content) : '' };
         const cache = this._ownershipConsensusCache ??= new Map();
         const cached = cache.get(target);
-        if (!force && cached?.result.status === 'consensus' && record?.remote_status !== 'missing'
+        if (cached?.result.status === 'consensus' && cached.observedVersion === observation.version && record?.remote_status !== 'missing'
+            && (!record?.remote_owner_md_sha256 || record.remote_owner_md_sha256 === cached.result.owner_md_sha256)
             && (observedEtag === cached.observedEtag || observedEtag === cached.result.agent_md_etag)
             && (typeof record?.content !== 'string' || ownershipSha256(record.content) === cached.result.agent_md_sha256)) {
             cached.observedEtag = observedEtag;
             return { ...cached.result };
         }
-        if (!force && !cached) {
+        if (!cached) {
             const local = manager.localOwnershipConsensus(target, record);
             if (local) {
-                cache.set(target, { observedEtag, result: local });
+                cache.set(target, { observedEtag, observedVersion: observation.version, result: local });
                 return { ...local };
             }
         }
         cache.delete(target);
         const result = { status: 'unavailable', sub_aid: target, owner_aid: null, relation_version: 0, lock: 'unlocked', agent_md_etag: '', agent_md_sha256: '' };
-        const entry = { observedEtag, result: { ...result } };
+        const entry = { observedEtag, observedVersion: observation.version, result: { ...result } };
         cache.set(target, entry);
+        let consensusContent;
         try {
             const snapshot = await manager.readOwnershipFresh(target);
+            consensusContent = snapshot.content;
+            if (snapshot.owner_md_sha256)
+                result.owner_md_sha256 = snapshot.owner_md_sha256;
             Object.assign(result, { relation_version: snapshot.relation_version, lock: snapshot.lock, agent_md_etag: snapshot.etag,
                 agent_md_sha256: snapshot.exists ? ownershipSha256(snapshot.content) : '' });
             if (snapshot.ownership_status)
@@ -1454,11 +1482,15 @@ export class AUNClient {
             result.retryable = result.status === 'unavailable';
         }
         if (this._agentMdManager === manager && this._ownershipConsensusCache === cache && cache.get(target) === entry) {
-            entry.result = { ...result };
             try {
-                manager.cacheOwnershipSnapshot(target, result, observation);
+                if (manager.cacheOwnershipSnapshot(target, result, observation, consensusContent))
+                    entry.result = { ...result };
+                else
+                    cache.delete(target);
+            }
+            catch {
+                cache.delete(target);
             }
-            catch { }
         }
         return result;
     }
@@ -2118,6 +2150,7 @@ export class AUNClient {
             throw ownershipFailure('conflict', 'entity lifecycle ownership action changed');
         const ownership = { statement: declaration.statement, action, ...(transfer ? { transfer: { new_owner_aid: ownershipAid(newOwner, 'new_owner_aid'), target_relation_version: declaration.statement.relation_version + 1, expires_at: Number(params.expires_at ?? Math.floor(Date.now() / 1000) + 3600) } } : {}) };
         const raw = signOwnershipFile(owner, `---\nowner_aid: ${owner.aid}\nsub_aid: ${target}\nownership: ${JSON.stringify(ownership)}\n---\n`, 'owner');
+        await this._getOwnershipFiles().verifyFile(raw, 'owner', target, owner.aid, true);
         await storage.writeOwnerMd(owner.aid, target, raw, original, assertCurrent);
         return async (error) => {
             if (!(error instanceof AUNError) || error instanceof TimeoutError || error instanceof ConnectionError || error.retryable || isJsonObject(error.data) && error.data.committed === true || ![-32602, 4000, 4030, 403].includes(error.code) && !['INVALID_ARGUMENT', 'ROLE_ACCESS_DENIED', 'MEMBER_NOT_FOUND', 'permission_denied', 'member_banned', 'member_blocked'].includes(error.stringCode))
@@ -2263,12 +2296,14 @@ export class AUNClient {
         else {
             const payload = `---\nowner_aid: ${owner.aid}\nsub_aid: ${aid}\nownership: ${JSON.stringify({ statement, action: 'declare' })}\n---\n`;
             const raw = signOwnershipFile(owner, payload, 'owner');
+            await this._getOwnershipFiles().verifyFile(raw, 'owner', aid, owner.aid, true);
             assertCurrent();
             await storage.writeOwnerMd(owner.aid, aid, raw, original, assertCurrent);
         }
         const source = content ?? (observed.exists ? observed.content : buildDefaultAgentMd(aid, { type, name: String(entity.name ?? aid) }));
         const updated = updateOwnershipAgentMd(source, { owner: owner.aid, ownership: { statement } }).replace(/^entity_cert_fingerprint:.*(?:\r?\n|$)/m, '');
         const signed = signOwnershipFile(local.data.aid, updated, 'agent');
+        await this._getOwnershipFiles().verifyFile(signed, 'agent', aid, undefined, true);
         if (content === undefined) {
             if (!previous || previous.owner_aid !== owner.aid || previous.relation_version !== version) {
                 assertCurrent();
@@ -2463,28 +2498,43 @@ export class AUNClient {
         tokens.saveMetadata(orgAid, { org_identity_creation: null });
         return checkpoint.result;
     }
-    _schedulePostConnectRecovery() {
+    _schedulePostConnectRecovery(backgroundSync = this._sessionOptions.background_sync !== false) {
         this._postConnectRecoveryAbort?.abort();
         if (this._postConnectRecoveryTimer !== null)
             clearTimeout(this._postConnectRecoveryTimer);
         this._postConnectRecoveryTimer = null;
         const store = this._aidStore;
-        if (this._sessionOptions.background_sync === false)
-            return;
         const abort = new AbortController();
         this._postConnectRecoveryAbort = abort;
         const aid = this._aid, version = this._serviceEventIdentityVersion, connection = this._entityOwnershipConnection;
         const current = () => !abort.signal.aborted && aid === this._aid && version === this._serviceEventIdentityVersion && connection === this._entityOwnershipConnection && ['ready', 'connected'].includes(this._state) && !this._closing && !this._disconnecting;
+        const tasks = [];
+        if (!this._ownershipOperation)
+            tasks.push(() => this._checkIdentityAdmissionAfterConnect());
+        tasks.push(() => this._reconcileReadStates());
+        if (backgroundSync) {
+            tasks.push(() => this._recoverGroupInvites());
+            if (this._v2Session && this._sessionOptions.connection_kind !== 'short')
+                tasks.push(() => this._v2AutoConfirmPendingProposals());
+            tasks.push(() => this._delivery.restoreMessageClassPulls(), () => this._fillP2pGap());
+            if (store && !this._ownershipOperation)
+                tasks.push(() => this._resumeOrgIdentityAfterConnect(store, current));
+        }
+        const run = async () => {
+            for (let index = 0; index < tasks.length; index++) {
+                if (!current())
+                    return;
+                const pending = tasks[index]();
+                this._safeAsync(pending);
+                await pending.catch(() => { });
+                if (index + 1 < tasks.length)
+                    await this._sleep(1000 + Math.random() * 4000, abort.signal);
+            }
+        };
         this._postConnectRecoveryTimer = setTimeout(() => {
             this._postConnectRecoveryTimer = null;
-            if (!current())
-                return;
-            this._safeAsync(this._delivery.restoreMessageClassPulls());
-            void this._fillP2pGap().catch((exc) => {
-                this._clientLog.warn(`schedule post-connect P2P gap fill failed: ${formatCaughtError(exc)}`);
-            });
-            if (store && !this._ownershipOperation)
-                this._safeAsync(this._resumeOrgIdentityAfterConnect(store, current));
+            if (current())
+                this._safeAsync(run());
         }, 30_000 + Math.random() * 30_000);
         this._postConnectRecoveryTimer.unref?.();
     }
@@ -4978,18 +5028,11 @@ export class AUNClient {
             }
             this._lifecycle.assertConnectionAttemptOwner(connectionOwner);
             this._startBackgroundTasks();
-            this._safeAsync(this._reconcileReadStates());
             const connectionKind = String(params.connection_kind ?? 'long');
             const isShortConnection = connectionKind === 'short';
             const hasExplicitBackgroundSync = Object.prototype.hasOwnProperty.call(params, 'background_sync');
             const backgroundSyncEnabled = this._sessionOptions.background_sync !== false
                 && (!isShortConnection || hasExplicitBackgroundSync);
-            if (backgroundSyncEnabled) {
-                // 连接建立/恢复后先从事实列表恢复定向邀请提示；失败不影响连接本身。
-                this._safeAsync(this._recoverGroupInvites().catch((exc) => {
-                    this._clientLog.debug(`group invite recovery failed: ${formatCaughtError(exc)}`);
-                }));
-            }
             if (!isShortConnection) {
                 await this._v2E2EE.onConnected({ backgroundSync: backgroundSyncEnabled });
                 this._assertReconnectOwner(reconnectOwner);
@@ -5004,13 +5047,7 @@ export class AUNClient {
             // 群消息按惰性触发，不在此处主动 pull
             this._entityOwnershipConnection++;
             this._entityOwnershipChecks.clear();
-            if (!this._ownershipOperation)
-                this._safeAsync(this._checkIdentityAdmissionAfterConnect());
-            if (backgroundSyncEnabled)
-                this._schedulePostConnectRecovery();
-            if (!isShortConnection && backgroundSyncEnabled && this._v2Session) {
-                this._safeAsync(this._v2AutoConfirmPendingProposals());
-            }
+            this._schedulePostConnectRecovery(backgroundSyncEnabled);
             this._activateUdpStandby();
             this._clientLog.debug(`_connectOnce exit: elapsed=${Date.now() - tStart}ms gateway=${gatewayUrl}, aid=${this._aid ?? ''}`);
         }
@@ -6451,8 +6488,17 @@ export class AUNClient {
             reconnect: async () => {
                 if (this._closing || this._disconnecting)
                     throw new ConnectionError('client closed');
-                this._state = 'standby';
-                await this._lifecycle.connect(this._udpStandbyConnectOptions);
+                await this._sleep(reconnectSleepDelayMs(1000, RECONNECT_MAX_BASE_DELAY_MS));
+                const release = await acquireReconnectSlot(this._aid ?? '', task => task, ms => this._sleep(ms));
+                try {
+                    if (this._closing || this._disconnecting || this._udpStandby?.state === 'offline')
+                        throw new ConnectionError('client closed');
+                    this._state = 'standby';
+                    await this._lifecycle.connect(this._udpStandbyConnectOptions);
+                }
+                finally {
+                    release();
+                }
             },
         });
         this._udpStandby.activate(this._udpStandbyPolicy);
@@ -6580,9 +6626,10 @@ export class AUNClient {
                 next_retry_at: this._nextRetryAt,
             }))
                 return;
+            let releaseReconnectSlot;
             try {
-                // 抖动随当前 base 增长且不超过 max_base，避免首次重连被放大到几十秒。
                 await this._sleep(Math.max(0, this._nextRetryAt - Date.now()), reconnectAbort?.signal);
+                releaseReconnectSlot = await acquireReconnectSlot(this._aid ?? '', task => this._lifecycle.waitForAttempt(task, undefined, reconnectAbort ?? undefined), ms => this._sleep(ms, reconnectAbort?.signal));
                 if (!this._ownsReconnect(reconnectAbort))
                     return;
                 this._state = 'reconnecting';
@@ -6591,17 +6638,6 @@ export class AUNClient {
                     attempt,
                 }))
                     return;
-                // /health 仅作旁路诊断，不能阻止实际 WebSocket 重连。
-                if (this._gatewayUrl) {
-                    void this._discovery.checkHealth(this._gatewayUrl, 5_000)
-                        .then((healthy) => {
-                        if (!healthy)
-                            this._clientLog.warn(`reconnect health advisory failed: gateway=${this._gatewayUrl}`);
-                    })
-                        .catch((exc) => {
-                        this._clientLog.debug(`reconnect health advisory error: ${formatCaughtError(exc)}`);
-                    });
-                }
                 await this._transport.close();
                 if (!this._ownsReconnect(reconnectAbort))
                     return;
@@ -6638,7 +6674,7 @@ export class AUNClient {
                         this._sessionParams.access_token = '';
                     }
                 }
-                const candidates = await this._lifecycle.waitForAttempt(this._resolveGatewayCandidatesForAid(this._aid, true, reconnectAbort ?? undefined), undefined, reconnectAbort ?? undefined);
+                const candidates = await this._lifecycle.waitForAttempt(this._resolveGatewayCandidatesForAid(this._aid, this._migrationPending || this._migrationRevision.size > 0 || attempt % 3 === 2, reconnectAbort ?? undefined), undefined, reconnectAbort ?? undefined);
                 if (!this._ownsReconnect(reconnectAbort))
                     return;
                 this._sessionParams.gateways = [...candidates];
@@ -6698,6 +6734,9 @@ export class AUNClient {
                 }
                 delay = Math.min(delay * 2, maxBaseDelay);
             }
+            finally {
+                releaseReconnectSlot?.();
+            }
         }
     }
     /** 每轮重连从当前地址之后开始轮转，避免永远黏在失效的首个 Gateway。 */