@agentunion/fastaun 0.5.32 → 0.5.34

package/dist/client.d.ts

@@ -21,7 +21,7 @@ import { StorageVFS } from './storage/vfs.js';
 import { type JsonObject, type JsonValue, type RpcParams, type RpcResult, ConnectionState } from './types.js';
 import { AID } from './aid.js';
 import { type OwnershipConsensusResult } from './ownership-v21.js';
-import { type OwnershipTaskResult } from './ownership-workflow.js';
+import { type OwnershipRequestOptions, type OwnershipApprovalBatchResult, type OwnershipTaskResult } from './ownership-workflow.js';
 import { type CertificateMaterial } from './org-protocol.js';
 import { type RecordVerificationContext as SemanticRecordVerificationContext, type SemanticMessageVerificationContext } from './semantic-protocol.js';
 import type { SemanticPersistentState } from './semantic-facade.js';
@@ -263,6 +263,7 @@ export declare class AUNClient {
     private _peerDirectory;
     private _lifecycle;
     private _rpcPipeline;
+    private _syncChannelCoordinator;
     private _delivery;
     private _v2E2EE;
     private _groupState;
@@ -303,14 +304,14 @@ export declare class AUNClient {
     get_owner(): string | null;
     getOwnershipStatus(): Record<string, unknown>;
     get_ownership_status(): Record<string, unknown>;
-    bindOwneraid(ownerAid: string): Promise<OwnershipTaskResult>;
-    bindSubaid(subAid: string): Promise<OwnershipTaskResult>;
+    bindOwneraid(ownerAid: string, options?: OwnershipRequestOptions): Promise<OwnershipTaskResult>;
+    bindSubaid(subAid: string, options?: OwnershipRequestOptions): Promise<OwnershipTaskResult>;
     bindLocalSubaid(subClient: AUNClient): Promise<OwnershipTaskResult>;
     transferLocalSubaid(subClient: AUNClient, newOwnerClient: AUNClient): Promise<OwnershipTaskResult>;
     private _createOwnershipOperationClient;
     private _localOwnershipOperation;
     releaseSubaid(subAid: string): Promise<OwnershipTaskResult>;
-    transferSubaid(subAid: string, newOwnerAid: string): Promise<OwnershipTaskResult>;
+    transferSubaid(subAid: string, newOwnerAid: string, options?: OwnershipRequestOptions): Promise<OwnershipTaskResult>;
     checkOwnershipConsensus(subAid?: string, force?: boolean): Promise<OwnershipConsensusResult>;
     private _checkOwnershipConsensusFresh;
     bindAid(subjectAid: string, options?: {
@@ -331,6 +332,9 @@ export declare class AUNClient {
     bind_owner(ownerAid: string, options?: Parameters<AUNClient['bindOwner']>[1]): Promise<RpcResult>;
     releaseOwnership(subjectAid: string): Promise<RpcResult>;
     release_ownership(subjectAid: string): Promise<RpcResult>;
+    acceptOwnershipRequests(operationIds: string[]): Promise<OwnershipApprovalBatchResult>;
+    rejectOwnershipRequests(operationIds: string[], reason?: string): Promise<OwnershipApprovalBatchResult>;
+    private _approveOwnershipRequests;
     acceptOwnershipRequest(operationId: string): Promise<OwnershipTaskResult>;
     rejectOwnershipRequest(operationId: string, reason?: string): Promise<OwnershipTaskResult>;
     private _handleOwnershipMessage;
@@ -359,6 +363,7 @@ export declare class AUNClient {
     lookupPeer(aid: string, certFingerprint?: string | null): Promise<AID>;
     peers(): AID[];
     /** transport 的 meta observer：吸收 gateway 注入的 _meta 字段。失败不影响业务。 */
+    private _historyChannels;
     private _observeRpcMeta;
     isGroupIndexStale(groupAid: string): boolean;
     markGroupIndexFresh(groupAid: string, options: {

package/dist/client.js

@@ -26,6 +26,7 @@ import { AUNLogger } from './logger.js';
 import { normalizeGroupId } from './group-id.js';
 import { validateAIDFormat, validateGroupIDFormat } from './validators.js';
 import { RPCTransport } from './transport.js';
+import { SyncChannels } from './client/sync-channels.js';
 import { AuthFlow } from './auth.js';
 import { AgentMdManager, buildDefaultAgentMd, updateOwnershipAgentMd } from './agent-md.js';
 import { AgentMdChangeCoordinator } from './agent-md-changes.js';
@@ -54,7 +55,7 @@ import { AID } from './aid.js';
 import { certFingerprint, certMatchesFingerprint, normalizeFingerprintHex, publicKeyMatchesFingerprint } from './cert-utils.js';
 import { validateAgentMdCertificate, validateAgentMdDocument, validateAgentMdReadDocument } from './agent-md-schema.js';
 import { OwnershipFiles, OwnershipStorageAdapter, ownershipAid, ownershipFailure, ownershipSha256, parseOwnershipFile, signOwnershipFile } from './ownership-v21.js';
-import { OwnershipWorkflow, OWNERSHIP_SDK_MESSAGE_TYPE, parseOwnershipMessage } from './ownership-workflow.js';
+import { ownershipApprovalBatch, OwnershipWorkflow, OWNERSHIP_SDK_MESSAGE_TYPE, parseOwnershipMessage } from './ownership-workflow.js';
 import { canonicalJson, createCredential, createMemberCredential, signMembershipBinding, digest, validateMembershipBinding, verifyMembershipBinding, verifyCredentialSignature, createRepresentationProof, verifyServiceEvent, buildRequestBinding, validateRequestBinding, CredentialRenewal } from './org-protocol.js';
 import { SemanticProtocolError } from './semantic-protocol.js';
 function isPromiseLike(value) {
@@ -523,7 +524,16 @@ export class AUNClient {
             currentType: () => this.getType(), assertCurrent: () => this._ownershipOperationGuard?.(),
             recoverRequest: (operationId) => this._recoverOwnershipRequest(operationId),
             send: (to, payload, messageId) => this.call('message.send', { to, encrypt: true, message_id: messageId, payload: payload }),
-            emit: (event, payload) => { this._ownershipConsensusCache = new Map(); this._dispatcher.enqueue(event, payload); },
+            emit: (event, payload) => {
+                this._ownershipConsensusCache = new Map();
+                if (typeof payload.sub_aid === 'string') {
+                    try {
+                        this._agentMdManager.updateRecord(payload.sub_aid, (record) => { delete record.ownership_snapshot; });
+                    }
+                    catch { }
+                }
+                this._dispatcher.enqueue(event, payload);
+            },
         });
     }
     async _recoverOwnershipRequest(operationId) {
@@ -1041,6 +1051,7 @@ export class AUNClient {
     _peerDirectory;
     _lifecycle;
     _rpcPipeline;
+    _syncChannelCoordinator = null;
     _delivery;
     _v2E2EE;
     _groupState;
@@ -1152,6 +1163,7 @@ export class AUNClient {
         this._installRiskHooks();
         this._transport.setClassMessageHandler((event, payload) => this._controlMessages().onPush(payload, event.includes('group.')));
         this._transport.setProtocolMetaObserver((meta) => this._observeRpcMeta(meta));
+        this._transport.setSyncControlObserver((meta, method, params) => this._historyChannels().observe(meta, method, params));
         this._transport.setServiceEventVerifier((event, payload) => this._verifyIncomingServiceEvent(event, payload), () => this._identity?.aid ?? '', () => this._serviceEventIdentityVersion);
         this._transport.setProtocolDisconnectCallback((err, closeCode) => this._handleTransportDisconnect(err, closeCode));
         this._transport._onForegroundDrained = () => this._delivery.onForegroundPullsDrained();
@@ -1333,8 +1345,8 @@ export class AUNClient {
     get_ownership_status() {
         return this.getOwnershipStatus();
     }
-    async bindOwneraid(ownerAid) { return this._getOwnershipWorkflow().bindOwneraid(ownerAid); }
-    async bindSubaid(subAid) { return this._getOwnershipWorkflow().bindSubaid(subAid); }
+    async bindOwneraid(ownerAid, options) { return this._getOwnershipWorkflow().bindOwneraid(ownerAid, options); }
+    async bindSubaid(subAid, options) { return this._getOwnershipWorkflow().bindSubaid(subAid, options); }
     async bindLocalSubaid(subClient) { return this._localOwnershipOperation(subClient); }
     async transferLocalSubaid(subClient, newOwnerClient) { return this._localOwnershipOperation(subClient, newOwnerClient); }
     _createOwnershipOperationClient(slotId) {
@@ -1342,6 +1354,11 @@ export class AUNClient {
         const client = new AUNClient(AID._create({ aid: aid.aid, aunPath: aid.aunPath, certPem: aid.certPem, privateKeyPem: aid.privateKeyPem,
             certValid: aid.isCertValid(), privateKeyValid: aid.isPrivateKeyValid(), deviceId: this._deviceId, slotId,
             verifySsl: aid.verifySsl, rootCaPath: aid.rootCaPath, debug: aid.debug, aidStore: aid._aidStore }));
+        const identity = this._auth.loadIdentityOrNone(), token = String(identity?.access_token ?? ''), expiresAt = identity?.access_token_expires_at;
+        if (identity?.aid === aid.aid && token.startsWith('eyJ') && token.split('.').length === 3
+            && typeof expiresAt === 'number' && expiresAt > Date.now() / 1000 + 30) {
+            Object.assign(client._identity, { access_token: token, access_token_expires_at: expiresAt });
+        }
         client._ownershipOperation = true;
         client._ownershipType = this.getType();
         return client;
@@ -1383,24 +1400,34 @@ export class AUNClient {
         }
     }
     async releaseSubaid(subAid) { return this._getOwnershipWorkflow().releaseSubaid(subAid); }
-    async transferSubaid(subAid, newOwnerAid) { return this._getOwnershipWorkflow().transferSubaid(subAid, newOwnerAid); }
+    async transferSubaid(subAid, newOwnerAid, options) { return this._getOwnershipWorkflow().transferSubaid(subAid, newOwnerAid, options); }
     async checkOwnershipConsensus(subAid, force = false) {
         const target = ownershipAid(subAid ?? this._aid, 'sub_aid');
-        const record = this._agentMdManager.loadRecord(target);
+        const manager = this._agentMdManager;
+        const record = manager.loadRecord(target);
         const observedEtag = String(record?.remote_etag ?? '');
+        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'
-            && (observedEtag === cached.observedEtag || observedEtag === cached.result.agent_md_etag)) {
+            && (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) {
+            const local = manager.localOwnershipConsensus(target, record);
+            if (local) {
+                cache.set(target, { observedEtag, 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 } };
         cache.set(target, entry);
         try {
-            const snapshot = await this._agentMdManager.readOwnershipFresh(target);
+            const snapshot = await manager.readOwnershipFresh(target);
             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)
@@ -1420,8 +1447,13 @@ export class AUNClient {
             result.reason = error instanceof Error ? error.message : String(error);
             result.retryable = result.status === 'unavailable';
         }
-        if (cache.get(target) === entry)
+        if (this._agentMdManager === manager && this._ownershipConsensusCache === cache && cache.get(target) === entry) {
             entry.result = { ...result };
+            try {
+                manager.cacheOwnershipSnapshot(target, result, observation);
+            }
+            catch { }
+        }
         return result;
     }
     async _checkOwnershipConsensusFresh(subAid) {
@@ -1437,6 +1469,20 @@ export class AUNClient {
     async bind_owner(ownerAid, options = {}) { return this.bindOwner(ownerAid, options); }
     async releaseOwnership(subjectAid) { throw ownershipFailure('unsupported_protocol', 'legacy releaseOwnership is unsupported; use releaseSubaid'); }
     async release_ownership(subjectAid) { return this.releaseOwnership(subjectAid); }
+    async acceptOwnershipRequests(operationIds) {
+        return this._approveOwnershipRequests(operationIds);
+    }
+    async rejectOwnershipRequests(operationIds, reason) {
+        return this._approveOwnershipRequests(operationIds, true, reason);
+    }
+    async _approveOwnershipRequests(operationIds, reject = false, reason) {
+        const aid = this._aid, generation = this._serviceEventIdentityVersion;
+        return ownershipApprovalBatch(operationIds, async (operationId) => {
+            if (this._aid !== aid || this._serviceEventIdentityVersion !== generation)
+                throw new StateError('ownership approval identity changed', { stringCode: 'conflict' });
+            return reject ? this.rejectOwnershipRequest(operationId, reason) : this.acceptOwnershipRequest(operationId);
+        });
+    }
     async acceptOwnershipRequest(operationId) {
         return this._getOwnershipWorkflow().acceptOwnershipRequest(operationId);
     }
@@ -1655,6 +1701,7 @@ export class AUNClient {
         this._installRiskHooks();
         this._transport.setClassMessageHandler((event, payload) => this._controlMessages().onPush(payload, event.includes('group.')));
         this._transport.setProtocolMetaObserver((meta) => this._observeRpcMeta(meta));
+        this._transport.setSyncControlObserver((meta, method, params) => this._historyChannels().observe(meta, method, params));
         this._transport.setServiceEventVerifier((event, payload) => this._verifyIncomingServiceEvent(event, payload), () => this._identity?.aid ?? '', () => this._serviceEventIdentityVersion);
         this._transport.setProtocolDisconnectCallback((err, closeCode) => this._handleTransportDisconnect(err, closeCode));
         this._transport._onForegroundDrained = () => this._delivery.onForegroundPullsDrained();
@@ -1710,6 +1757,56 @@ export class AUNClient {
         return this._peerDirectory.peers();
     }
     /** transport 的 meta observer：吸收 gateway 注入的 _meta 字段。失败不影响业务。 */
+    _historyChannels() {
+        return this._syncChannelCoordinator ??= new SyncChannels({
+            main: () => this._transport,
+            current: () => this._state === 'ready' && !this._closing && this._transport.isConnected(),
+            wake: () => this._delivery?.requestBackgroundPullRecovery(),
+            owner: () => String(this._aid ?? ''),
+            namespace: (method, params) => this._rpcPipeline.pullGateKeyForCall(method, params).split('|')[0],
+            pendingNamespaces: () => [...this._delivery.pendingHistoryNamespaces(), ...this._rpcPipeline.pendingHistoryNamespaces()],
+            fail: (method, params, error) => this._dispatcher.enqueue('sync.error', { namespace: params.sender_aid ? this._delivery.peerNamespace(String(params.sender_aid)) : `group:${String(params.group_id ?? params.group_aid ?? '')}`, method, code: 'OVERSIZED_MESSAGE', error: error instanceof Error ? error.message : String(error) }),
+            create: async (parent, timeout = 35000, signal) => {
+                const deadline = Date.now() + timeout;
+                const dispatcher = new EventDispatcher(this._logger.for('aun_core.events'));
+                const transport = new RPCTransport({ eventDispatcher: dispatcher, rpcBudget: this._transport.rpcBudget, syncAuxiliary: true,
+                    timeout, verifySsl: this._configModel.verifySsl, logger: this._logger.for('aun_core.transport') });
+                transport.setSyncControlObserver((meta, method, params) => this._historyChannels().observe(meta, method, params));
+                transport.setRequestAdmission(this._transport._requestAdmission);
+                transport.setRequestCheck(this._transport._requestCheck);
+                transport.setProtocolDisconnectCallback(() => this._historyChannels().auxiliaryDisconnected(transport));
+                const abort = () => { void transport.close(); };
+                signal?.addEventListener('abort', abort, { once: true });
+                try {
+                    if (signal?.aborted)
+                        throw new TimeoutError('history sync cancelled', { retryable: true });
+                    const challenge = await transport.connect(this._gatewayUrl);
+                    if (Date.now() >= deadline || signal?.aborted)
+                        throw new TimeoutError('history sync deadline exceeded', { retryable: true });
+                    transport.setTimeout(Math.max(1, deadline - Date.now()));
+                    const token = AuthFlow._getCachedAccessToken(this._identity ?? {})
+                        || AuthFlow._getCachedAccessToken(this._sessionParams ?? {});
+                    if (!token)
+                        throw new ConnectionError('auxiliary sync connection has no valid access token');
+                    const hello = await this._auth.initializeWithToken(transport, challenge, token, { deviceId: this._deviceId,
+                        slotId: this._slotId, connectionKind: 'short', shortTtlMs: 0, extraInfo: { _sync_parent: parent } });
+                    if (!isJsonObject(hello.connection) || !hello.connection.id)
+                        throw new ConnectionError('auxiliary sync connection has no identity');
+                    if (!isJsonObject(hello.negotiated_capabilities) || hello.negotiated_capabilities.elastic_connections_v1 !== true || hello.negotiated_capabilities.sync_channels_v1 !== true)
+                        throw new ConnectionError('auxiliary sync capabilities were not negotiated');
+                    return { id: String(hello.connection.id), transport, dispose: () => dispatcher.close() };
+                }
+                catch (error) {
+                    await transport.close();
+                    await dispatcher.close();
+                    throw error;
+                }
+                finally {
+                    signal?.removeEventListener('abort', abort);
+                }
+            },
+        });
+    }
     _observeRpcMeta(meta) {
         this._agentMdManager.observeRpcMeta(meta, this._aid);
         this._groupIndexMetaCache.observeRpcMeta(meta, { localAid: this._aid ?? '' });
@@ -2028,6 +2125,9 @@ export class AUNClient {
                     if (!pending?.private_key_pem || !pending.public_key_der_b64)
                         return false;
                 }
+                const local = this._agentMdManager.localOwnershipConsensus(target, this._agentMdManager.loadRecord(target));
+                if (local?.owner_aid === this._aid)
+                    return true;
                 const result = await this._entityLifecycle(target, type);
                 const data = result;
                 const entity = (isJsonObject(data.group) ? data.group : isJsonObject(data.organization) ? data.organization : data);
@@ -2201,12 +2301,19 @@ export class AUNClient {
         if (!aid)
             return;
         try {
-            const checked = await this._agentMdManager.check(aid, 0);
-            if (!checked.remote_found) {
-                await this._ensureInitialAgentMd();
-            }
-            else if (checked.in_sync === false) {
-                await this._agentMdManager.download(aid);
+            const record = this._agentMdManager.loadRecord(aid);
+            const verified = record?.verified_agent_md;
+            const local = record?.content && record.remote_status !== 'missing' && record.remote_etag
+                && (record.local_etag === record.remote_etag || record.verify_status === 'verified' && verified?.etag === record.remote_etag && verified.content_hash === record.local_etag
+                    || this._agentMdManager.localOwnershipConsensus(aid, record));
+            if (!local) {
+                const checked = await this._agentMdManager.check(aid, 0);
+                if (!checked.remote_found) {
+                    await this._ensureInitialAgentMd();
+                }
+                else if (checked.in_sync === false) {
+                    await this._agentMdManager.download(aid);
+                }
             }
         }
         catch (exc) {
@@ -4512,6 +4619,7 @@ export class AUNClient {
     // ── 内部：连接 ────────────────────────────────────────────
     /** 执行一次连接流程 */
     async _connectOnce(params, allowReauth, reconnectOwner, connectionOwner) {
+        this._syncChannelCoordinator?.reset();
         await this._restoreRiskState();
         this._assertRiskReconnect();
         this._riskNegotiated = false;
@@ -4623,6 +4731,7 @@ export class AUNClient {
             this._migrationPending = false;
             this._lastDisconnectInfo = null;
             this._state = 'ready';
+            this._historyChannels().bind(this._gatewayConnectionId, this._negotiatedCapabilities.elastic_connections_v1 === true && this._negotiatedCapabilities.sync_channels_v1 === true && params.connection_kind !== 'short');
             this._connectedAt = Date.now();
             if (Array.isArray(params.gateways)) {
                 this._gatewayCandidates = [...new Set(params.gateways
@@ -5615,6 +5724,7 @@ export class AUNClient {
     }
     /** 停止所有后台任务 */
     _stopBackgroundTasks() {
+        this._syncChannelCoordinator?.reset();
         this._stopCredentialRenewal();
         this._auth.invalidateStrictPkiCache();
         this._certCache.clear();