@agentunion/fastaun 0.5.11 → 0.5.12

package/dist/client.d.ts

@@ -118,6 +118,9 @@ export declare class AUNClient {
     private _seqTrackerContext;
     /** 惰性群同步：已同步过的 group_id 集合 */
     private _groupSynced;
+    /** 群定向邀请按 group_id + invitee_aid 聚合去重。 */
+    private _groupInviteAggregates;
+    private _groupInviteAggregatesLoaded;
     /** P2P 撤回去重：原始 message_id -> 时间戳，保证应用层只回调一次 */
     _messageRecallSeen: Map<string, number>;
     /** 群撤回去重：group_id|sorted(message_ids) -> 时间戳，保证应用层只回调一次 */
@@ -272,6 +275,7 @@ export declare class AUNClient {
     private _checkIdentityAdmissionAfterConnect;
     private _runGroupIdentityOperation;
     createGroup(params?: RpcParams, options?: CreateGroupOptions): Promise<RpcResult>;
+    private _inviteInitialGroupMembers;
     private _groupAgentMdContent;
     private _uploadGroupAgentMd;
     bindGroupAid(params?: RpcParams, options?: BindGroupAidOptions): Promise<RpcResult>;
@@ -367,6 +371,19 @@ export declare class AUNClient {
     /** 将 SeqTracker 状态保存到 keystore */
     private _saveSeqTrackerState;
     private _persistSeq;
+    private static readonly GROUP_INVITE_METADATA_KEY;
+    private _groupInviteArray;
+    private _groupInvitePayload;
+    private _groupInviteKey;
+    private _loadGroupInviteAggregates;
+    private _persistGroupInviteAggregates;
+    private _onRawGroupInviteCreated;
+    private _onRawGroupInviteFinalized;
+    private _handleGroupInviteAggregate;
+    /** 连接建立/恢复后从事实列表补发尚未提示的群级邀请。 */
+    private _recoverGroupInvites;
+    /** 接受/拒绝/撤回成功后清理本地待处理聚合项。 */
+    private clearGroupInviteAggregate;
     private _commitSeqTrackerState;
     private _persistRepairedSeq;
     private _clampAckSeq;

package/dist/client.js

@@ -124,7 +124,7 @@ const MAX_NOTIFY_PAYLOAD_SIZE = 64 * 1024;
 // P1-23: 非幂等方法使用更长超时（35s），避免 SDK 10s 超时 < gateway 30s 处理时间
 const NON_IDEMPOTENT_TIMEOUT_MS = 35_000;
 const NON_IDEMPOTENT_METHODS = new Set([
-    'message.send', 'mail.send', 'group.send', 'group.create', 'group.invite',
+    'message.send', 'mail.send', 'group.send', 'group.create',
     'group.kick', 'group.remove_member', 'group.leave', 'group.dissolve',
     'group.set_settings',
     'group.update_announcement', 'group.update_rules',
@@ -150,6 +150,7 @@ const NON_IDEMPOTENT_METHODS = new Set([
     'auth.create_aid', 'auth.renew_cert', 'auth.rekey',
     'message.thought.put', 'group.thought.put',
     'group.add_member', 'group.bind_group_aid', 'group.complete_transfer',
+    'group.accept_invite', 'group.reject_invite', 'group.revoke_invite',
     'collab.create', 'collab.commit', 'collab.clone',
     'collab.prune', 'collab.unregister',
     'collab.tag.create', 'collab.tag.restore',
@@ -174,6 +175,8 @@ const SIGNED_METHODS = new Set([
     'group.review_join_request',
     'group.batch_review_join_request',
     'group.request_join', 'group.use_invite_code',
+    'group.invite_member', 'group.list_my_invites', 'group.accept_invite',
+    'group.reject_invite', 'group.revoke_invite',
     'group.thought.put',
     'message.thought.put',
     'group.set_settings',
@@ -468,6 +471,9 @@ export class AUNClient {
     _seqTrackerContext = null;
     /** 惰性群同步：已同步过的 group_id 集合 */
     _groupSynced = new Set();
+    /** 群定向邀请按 group_id + invitee_aid 聚合去重。 */
+    _groupInviteAggregates = new Map();
+    _groupInviteAggregatesLoaded = false;
     /** P2P 撤回去重：原始 message_id -> 时间戳，保证应用层只回调一次 */
     _messageRecallSeen = new Map();
     /** 群撤回去重：group_id|sorted(message_ids) -> 时间戳，保证应用层只回调一次 */
@@ -680,6 +686,9 @@ export class AUNClient {
         this._dispatcher.subscribe('_raw.group.message_recalled', (data) => this._safeAsync(this._onRawGroupMessageRecalled(data)));
         // 群组变更事件：透传并触发 V2 state/SPK 维护
         this._dispatcher.subscribe('_raw.group.changed', (data) => this._onRawGroupChanged(data));
+        // 定向邀请底层事件：按群 + 目标 AID 聚合后向应用层只提示一次。
+        this._dispatcher.subscribe('_raw.group.invite_created', (data) => this._onRawGroupInviteCreated(data));
+        this._dispatcher.subscribe('_raw.group.invite_finalized', (data) => this._onRawGroupInviteFinalized(data));
         // V2 state proposal 服务平面事件：owner/admin 负责确认或重新提案
         this._dispatcher.subscribe('_raw.group.v2.state_proposed', (data) => this._safeAsync(this._onV2StateProposed(data)));
         this._dispatcher.subscribe('_raw.group.v2.state_retry_needed', (data) => this._safeAsync(this._onV2StateRetryNeeded(data)));
@@ -1153,6 +1162,8 @@ export class AUNClient {
         }
         this._aidStore = store;
         const payload = { ...params };
+        const initialMembers = payload.members;
+        delete payload.members;
         if (payload.group_name === undefined && payload.groupName !== undefined) {
             payload.group_name = payload.groupName;
             delete payload.groupName;
@@ -1180,7 +1191,8 @@ export class AUNClient {
             const result = { ...createdMap, ...boundMap, group: { ...createdGroup, ...boundGroup } };
             const postprocessParams = { ...payload };
             delete postprocessParams._defer_group_ready_postprocess;
-            return await this._groupState.postprocessResult('group.create', postprocessParams, result);
+            const processed = await this._groupState.postprocessResult('group.create', postprocessParams, result);
+            return await this._inviteInitialGroupMembers(processed, groupId, initialMembers);
         }
         const pendingKey = `create:${String(payload.group_name).trim().toLowerCase()}`;
         const keystore = store._keystore;
@@ -1223,7 +1235,32 @@ export class AUNClient {
         }
         const postprocessParams = { ...payload };
         delete postprocessParams._defer_group_ready_postprocess;
-        return await this._groupState.postprocessResult('group.create', postprocessParams, result);
+        const processed = await this._groupState.postprocessResult('group.create', postprocessParams, result);
+        return await this._inviteInitialGroupMembers(processed, String(group.group_id ?? groupAid).trim(), initialMembers);
+    }
+    async _inviteInitialGroupMembers(result, groupId, members) {
+        const invites = [];
+        const inviteErrors = [];
+        const seen = new Set();
+        if (Array.isArray(members)) {
+            for (const item of members) {
+                const aid = typeof item === 'string' ? item.trim() : (isJsonObject(item) ? String(item.aid ?? '').trim() : '');
+                const memberType = isJsonObject(item) ? String(item.member_type ?? '').trim() : '';
+                if (!aid || aid === String(this._aid ?? '').trim() || seen.has(aid))
+                    continue;
+                seen.add(aid);
+                const params = { group_id: groupId, invitee_aid: aid };
+                if (memberType)
+                    params.member_type = memberType;
+                try {
+                    invites.push(await this.group.inviteMember(params));
+                }
+                catch (err) {
+                    inviteErrors.push({ aid, error: err instanceof Error ? err.message : String(err) });
+                }
+            }
+        }
+        return { ...(isJsonObject(result) ? result : {}), invites, invite_errors: inviteErrors };
     }
     _groupAgentMdContent(groupAid, params, group) {
         const explicit = params.group_agent_md ?? params.groupAgentMd ?? params.content;
@@ -2381,6 +2418,225 @@ export class AUNClient {
     _persistSeq(ns, forceSeq) {
         return this._delivery.persistSeq(ns, forceSeq);
     }
+    static GROUP_INVITE_METADATA_KEY = 'group_invites_pending_v1';
+    _groupInviteArray(value) {
+        if (Array.isArray(value))
+            return value.map((item) => String(item ?? '').trim()).filter(Boolean);
+        const item = String(value ?? '').trim();
+        return item ? [item] : [];
+    }
+    _groupInvitePayload(data) {
+        if (!isJsonObject(data))
+            return null;
+        const source = data;
+        const groupId = normalizeGroupId(source.group_id ?? source.group_aid ?? source.groupId ?? source.groupAid);
+        const inviteeAid = String(source.invitee_aid ?? source.inviteeAid ?? this._aid ?? '').trim();
+        if (!groupId || !inviteeAid)
+            return null;
+        if (this._aid && inviteeAid.toLowerCase() !== this._aid.toLowerCase())
+            return null;
+        const inviteIds = this._groupInviteArray(source.invite_ids ?? source.invite_id ?? source.inviteIds);
+        const inviterAids = this._groupInviteArray(source.inviter_aids ?? source.inviter_aid ?? source.inviterAids);
+        return {
+            ...source,
+            group_id: groupId,
+            group_aid: String(source.group_aid ?? groupId).trim() || groupId,
+            invite_ids: inviteIds,
+            inviter_aids: inviterAids,
+            invitee_aid: inviteeAid,
+            role: String(source.role ?? 'member'),
+            member_type: String(source.member_type ?? 'human'),
+            status: String(source.status ?? 'pending').toLowerCase() || 'pending',
+        };
+    }
+    _groupInviteKey(payload) {
+        return `${String(payload.group_id ?? '').trim().toLowerCase()}\u0000${String(payload.invitee_aid ?? '').trim().toLowerCase()}`;
+    }
+    _loadGroupInviteAggregates() {
+        if (this._groupInviteAggregatesLoaded)
+            return;
+        this._groupInviteAggregatesLoaded = true;
+        const aid = String(this._aid ?? '').trim();
+        const store = this._tokenStore;
+        if (!aid || !store || typeof store.loadMetadata !== 'function')
+            return;
+        try {
+            const raw = store.loadMetadata(aid)?.[AUNClient.GROUP_INVITE_METADATA_KEY];
+            const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw;
+            if (!isJsonObject(parsed))
+                return;
+            for (const [key, value] of Object.entries(parsed)) {
+                if (isJsonObject(value) && String(value.status ?? 'pending').toLowerCase() === 'pending') {
+                    this._groupInviteAggregates.set(key, value);
+                }
+            }
+        }
+        catch (exc) {
+            this._clientLog.debug(`group invite metadata restore failed: ${formatCaughtError(exc)}`);
+        }
+    }
+    _persistGroupInviteAggregates() {
+        const aid = String(this._aid ?? '').trim();
+        const store = this._tokenStore;
+        if (!aid || !store || typeof store.saveMetadata !== 'function')
+            return;
+        try {
+            const values = {};
+            for (const [key, value] of this._groupInviteAggregates)
+                values[key] = value;
+            store.saveMetadata(aid, { [AUNClient.GROUP_INVITE_METADATA_KEY]: JSON.stringify(values) });
+        }
+        catch (exc) {
+            this._clientLog.debug(`group invite metadata persist failed: ${formatCaughtError(exc)}`);
+        }
+    }
+    async _onRawGroupInviteCreated(data) {
+        await this._handleGroupInviteAggregate(data);
+    }
+    async _onRawGroupInviteFinalized(data) {
+        const payload = this._groupInvitePayload(data);
+        if (!payload)
+            return;
+        this._loadGroupInviteAggregates();
+        const key = this._groupInviteKey(payload);
+        const existing = this._groupInviteAggregates.get(key);
+        if (!existing)
+            return;
+        const source = data;
+        const status = String(payload.status ?? '').toLowerCase();
+        const aggregateStatus = String(source.aggregate_status ?? source.aggregateStatus ?? '').toLowerCase();
+        const remainingPending = source.remaining_pending === true
+            || source.remaining_pending === 1
+            || String(source.remaining_pending ?? '').toLowerCase() === 'true';
+        const pending = source.pending === true
+            || source.pending === 1
+            || String(source.pending ?? '').toLowerCase() === 'true';
+        const pendingIds = this._groupInviteArray(source.pending_invite_ids ?? source.pendingInviteIds);
+        const pendingInviters = this._groupInviteArray(source.pending_inviter_aids ?? source.pendingInviterAids);
+        const currentIds = this._groupInviteArray(existing.invite_ids);
+        const inviteId = String(source.invite_id ?? '').trim();
+        const inferredPartialRevoke = status === 'revoked' && inviteId
+            && currentIds.length > 1 && currentIds.includes(inviteId);
+        const leavesPending = remainingPending || pending || status === 'pending'
+            || aggregateStatus === 'pending' || pendingIds.length > 0 || inferredPartialRevoke;
+        if (!leavesPending) {
+            this._groupInviteAggregates.delete(key);
+        }
+        else {
+            const finalizedIds = new Set(remainingPending && inviteId
+                ? [inviteId]
+                : this._groupInviteArray(payload.invite_ids));
+            const nextIds = pendingIds.length > 0
+                ? pendingIds
+                : this._groupInviteArray(existing.invite_ids).filter((id) => !finalizedIds.has(id));
+            if (nextIds.length === 0) {
+                this._groupInviteAggregates.delete(key);
+            }
+            else {
+                existing.invite_ids = nextIds;
+                existing.inviter_aids = pendingInviters.length > 0
+                    ? pendingInviters
+                    : this._groupInviteArray(existing.inviter_aids);
+            }
+        }
+        this._persistGroupInviteAggregates();
+    }
+    async _handleGroupInviteAggregate(data) {
+        const payload = this._groupInvitePayload(data);
+        if (!payload)
+            return;
+        this._loadGroupInviteAggregates();
+        const status = String(payload.status ?? 'pending').toLowerCase();
+        const key = this._groupInviteKey(payload);
+        if (status !== 'pending') {
+            if (this._groupInviteAggregates.delete(key))
+                this._persistGroupInviteAggregates();
+            return;
+        }
+        const existing = this._groupInviteAggregates.get(key);
+        if (existing) {
+            existing.invite_ids = [...new Set([
+                    ...this._groupInviteArray(existing.invite_ids),
+                    ...this._groupInviteArray(payload.invite_ids),
+                ])];
+            existing.inviter_aids = [...new Set([
+                    ...this._groupInviteArray(existing.inviter_aids),
+                    ...this._groupInviteArray(payload.inviter_aids),
+                ])];
+            this._persistGroupInviteAggregates();
+            return;
+        }
+        const snapshot = {
+            ...payload,
+            invite_ids: this._groupInviteArray(payload.invite_ids),
+            inviter_aids: this._groupInviteArray(payload.inviter_aids),
+        };
+        this._groupInviteAggregates.set(key, snapshot);
+        this._persistGroupInviteAggregates();
+        this._dispatcher.enqueue('group.invite_received', { ...snapshot, invite_ids: [...this._groupInviteArray(snapshot.invite_ids)], inviter_aids: [...this._groupInviteArray(snapshot.inviter_aids)] });
+    }
+    /** 连接建立/恢复后从事实列表补发尚未提示的群级邀请。 */
+    async _recoverGroupInvites(result) {
+        let response = result;
+        let cursor = '';
+        const seen = new Set();
+        do {
+            if (response === undefined) {
+                response = await this.call('group.list_my_invites', cursor ? { cursor } : {});
+            }
+            let items = [];
+            let nextCursor = '';
+            if (Array.isArray(response))
+                items = response;
+            else if (isJsonObject(response)) {
+                const responseObject = response;
+                if (Array.isArray(responseObject.items))
+                    items = responseObject.items;
+                else if (Array.isArray(responseObject.invites))
+                    items = responseObject.invites;
+                else if (isJsonObject(responseObject.data) && Array.isArray(responseObject.data.items))
+                    items = responseObject.data.items;
+                nextCursor = String(responseObject.next_cursor ?? responseObject.nextCursor ?? responseObject.cursor ?? '');
+            }
+            for (const item of items) {
+                const payload = this._groupInvitePayload(item);
+                if (payload)
+                    seen.add(this._groupInviteKey(payload));
+                await this._handleGroupInviteAggregate(item);
+            }
+            cursor = nextCursor;
+            response = undefined;
+        } while (cursor);
+        this._loadGroupInviteAggregates();
+        let stale = false;
+        for (const key of this._groupInviteAggregates.keys()) {
+            if (!seen.has(key)) {
+                this._groupInviteAggregates.delete(key);
+                stale = true;
+            }
+        }
+        if (stale)
+            this._persistGroupInviteAggregates();
+    }
+    /** 接受/拒绝/撤回成功后清理本地待处理聚合项。 */
+    clearGroupInviteAggregate(params) {
+        this._loadGroupInviteAggregates();
+        const input = params ?? {};
+        const inviteId = String(input.invite_id ?? input.inviteId ?? '').trim();
+        const groupId = normalizeGroupId(input.group_id ?? input.group_aid ?? input.groupId ?? input.groupAid);
+        const inviteeAid = String(input.invitee_aid ?? input.inviteeAid ?? this._aid ?? '').trim();
+        let removed = false;
+        for (const [key, value] of this._groupInviteAggregates) {
+            const matchesKey = groupId && inviteeAid && key === `${groupId.toLowerCase()}\u0000${inviteeAid.toLowerCase()}`;
+            const matchesInvite = inviteId && this._groupInviteArray(value.invite_ids).includes(inviteId);
+            if (matchesKey || matchesInvite) {
+                this._groupInviteAggregates.delete(key);
+                removed = true;
+            }
+        }
+        if (removed)
+            this._persistGroupInviteAggregates();
+    }
     _commitSeqTrackerState(ns) {
         return this._delivery.commitSeqTrackerState(ns);
     }
@@ -2394,19 +2650,10 @@ export class AUNClient {
         return this._delivery.clampAckParams(method, params);
     }
     _repairPushContiguousBound(ns, pushSeq, hasPayload, label) {
-        if (!ns || !Number.isFinite(pushSeq) || pushSeq <= 0) {
-            return ns ? this._seqTracker.getContiguousSeq(ns) : 0;
-        }
-        const contig = this._seqTracker.getContiguousSeq(ns);
-        const shouldRepair = contig > pushSeq;
-        if (!shouldRepair)
-            return contig;
-        const repairedTo = Math.max(0, pushSeq - 1);
-        this._seqTracker.repairContiguousSeq(ns, repairedTo);
-        const repaired = this._seqTracker.getContiguousSeq(ns);
-        this._persistRepairedSeq(ns);
-        this._clientLog.warn(`${label} push repaired contiguous_seq: ns=${ns} payload=${hasPayload} push_seq=${pushSeq} contiguous=${contig}->${repaired}`);
-        return repaired;
+        void pushSeq;
+        void hasPayload;
+        void label;
+        return ns ? this._seqTracker.getContiguousSeq(ns) : 0;
     }
     // ── URL 辅助 ──────────────────────────────────────────────
     /** 跨域时将 Gateway URL 替换为 peer 所在域的 Gateway URL */
@@ -2558,6 +2805,12 @@ export class AUNClient {
             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);