@agentunion/fastaun-browser 0.5.4 → 0.5.6

package/dist/tools/cross-sdk-agent.js

@@ -5,7 +5,7 @@ import * as https from 'node:https';
 import * as crypto from 'node:crypto';
 import * as fs from 'node:fs';
 import { URL } from 'node:url';
-import { AIDStore, AUNClient } from '../index.js';
+import { AID, AIDStore, AUNClient, __version__ } from '../index.js';
 import { publicKeyFingerprint } from '../cert-utils.js';
 function installNodeBrowserShims() {
     const root = globalThis;
@@ -122,7 +122,7 @@ function envelopeMetadata(data) {
 }
 class CrossSdkJsAgent {
     language = 'js';
-    sdkVersion = 'unknown';
+    sdkVersion = __version__;
     aid = textOf(process.env.AUN_TEST_AID || `cross-js-${crypto.randomUUID().slice(0, 8)}.agentid.pub`).trim();
     issuer = textOf(process.env.AUN_TEST_ISSUER || 'agentid.pub').trim() || 'agentid.pub';
     slotId = textOf(process.env.AUN_TEST_SLOT_ID || `cross-sdk-js-${crypto.randomUUID().slice(0, 8)}`).trim();
@@ -133,15 +133,36 @@ class CrossSdkJsAgent {
     startupError = '';
     inbox = [];
     groupInbox = [];
+    rawPushObservations = [];
+    rawPushObservationId = '';
+    rawPushRpcMethods = [];
+    rpcObservedTransports = new WeakSet();
+    groupChangedEvents = [];
     traces = new Map();
     sendResults = new Map();
+    inlineRealtimePayloadV1 = true;
     constructor() {
-        this.client = new AUNClient();
-        const internal = this.client;
+        this.client = this.newClient();
+    }
+    async start() {
+        this.bindClientEvents();
+        await this.ensureConnected(false);
+        this.ready = true;
+    }
+    newClient() {
+        const client = new AUNClient();
+        const internal = client;
         if (internal._configModel)
             internal._configModel.requireForwardSecrecy = false;
+        return client;
     }
-    async start() {
+    bindClientEvents() {
+        this.installTransportRpcObserver();
+        this.client.on('_raw.message.received', (data) => this.storeRawPushObservation('_raw.message.received', 'p2p', 'legacy', data));
+        this.client.on('_raw.peer.v2.message_received', (data) => this.storeRawPushObservation('_raw.peer.v2.message_received', 'p2p', 'v2', data));
+        this.client.on('_raw.group.message_created', (data) => this.storeRawPushObservation('_raw.group.message_created', 'group', 'legacy', data));
+        this.client.on('_raw.group.v2.message_created', (data) => this.storeRawPushObservation('_raw.group.v2.message_created', 'group', 'v2', data));
+        this.client.on('_raw.group.changed', (data) => this.storeRawGroupChangedObservation(data));
         this.client.on('message.received', (msg) => {
             void this.storeInboxItem(this.normalizeMessage(msg, true));
         });
@@ -154,8 +175,103 @@ class CrossSdkJsAgent {
         this.client.on('group.message_undecryptable', (msg) => {
             void this.storeGroupInboxItem(this.normalizeGroupMessage(msg, false, 'undecryptable'));
         });
-        await this.ensureConnected();
-        this.ready = true;
+        this.client.on('group.changed', (data) => this.storeGroupChangedPublicEvent(data));
+    }
+    installTransportRpcObserver() {
+        const transport = this.client._transport;
+        transport?.setTraceMode('diag');
+        if (!transport?.call || this.rpcObservedTransports.has(transport))
+            return;
+        const originalCall = transport.call;
+        this.rpcObservedTransports.add(transport);
+        transport.call = async (method, params, timeout, trace, background) => {
+            this.storeRawPushRpcMethod({ type: 'rpc', method, request_window: this.rawPushRequestWindow(params) });
+            let requestParams = params;
+            if (method === 'auth.connect' && !this.inlineRealtimePayloadV1 && jsonObjectOf(params)) {
+                const request = { ...jsonObjectOf(params) };
+                const capabilities = jsonObjectOf(request.capabilities);
+                if (capabilities) {
+                    delete capabilities.inline_realtime_payload_v1;
+                    request.capabilities = capabilities;
+                }
+                requestParams = request;
+            }
+            return await originalCall.call(transport, method, requestParams, timeout, trace, background);
+        };
+    }
+    storeRawPushObservation(rawEvent, scope, defaultKind, value) {
+        const data = jsonObjectOf(value) ?? {};
+        const hasInline = Object.prototype.hasOwnProperty.call(data, 'inline_message');
+        const inlineMessage = jsonObjectOf(data.inline_message);
+        this.rawPushObservations.push({
+            observation_id: this.rawPushObservationId,
+            time: Date.now(), raw_event: rawEvent, scope, group_id: textOf(data.group_id),
+            kind: textOf(data.kind || defaultKind),
+            action: textOf(data.action),
+            event_seq: Number(data.event_seq ?? 0) || 0,
+            seq: Number(data.seq ?? data.message_seq ?? data.msg_seq ?? 0) || 0,
+            message_id: textOf(data.message_id ?? data.id ?? ''),
+            has_inline: hasInline,
+            inline_version: textOf(data.inline_version ?? inlineMessage?.version ?? ''),
+            inline_is_object: inlineMessage !== null,
+            target_device_present: Boolean(textOf(data.target_device_id)),
+            target_slot_present: Boolean(textOf(data.target_slot_id)),
+            target_device_id: textOf(data.target_device_id),
+            target_slot_id: textOf(data.target_slot_id),
+            inline_candidate_keys: Object.keys(data).filter((key) => key.startsWith('inline_') || key.startsWith('_inline_message_candidates_') || key === '_group_inline_plain_source_v1' || key === '_group_inline_v2_source_v1').sort(),
+            top_level_sensitive_keys: Object.keys(data).filter((key) => [
+                'inline_message', 'payload', 'message', 'envelope_json', 'ciphertext',
+                '_inline_message_candidates_v1', '_group_inline_plain_source_v1', '_group_inline_v2_source_v1',
+            ].includes(key)).sort(),
+        });
+        if (this.rawPushObservations.length > 1000)
+            this.rawPushObservations = this.rawPushObservations.slice(-1000);
+    }
+    storeRawGroupChangedObservation(value) {
+        this.storeRawPushObservation('_raw.group.changed', 'group', 'changed', value);
+    }
+    storeGroupChangedPublicEvent(value) {
+        const data = jsonObjectOf(value) ?? {};
+        this.groupChangedEvents.push({
+            observation_id: this.rawPushObservationId,
+            time: Date.now(),
+            group_id: textOf(data.group_id),
+            action: textOf(data.action),
+            event_seq: Number(data.event_seq ?? 0) || 0,
+            event_id: textOf(data.event_id),
+            envelope_present: jsonObjectOf(data.envelope) !== null,
+        });
+        if (this.groupChangedEvents.length > 1000)
+            this.groupChangedEvents = this.groupChangedEvents.slice(-1000);
+    }
+    storeRawPushRpcMethod(traceInfo) {
+        if (traceInfo.type !== 'rpc')
+            return;
+        if (!this.rawPushObservationId)
+            return;
+        const method = textOf(traceInfo.method).trim();
+        if (!method)
+            return;
+        const requestWindow = jsonObjectOf(traceInfo.request_window) ?? {};
+        this.rawPushRpcMethods.push({
+            observation_id: this.rawPushObservationId,
+            time: Date.now(),
+            method,
+            ...this.rawPushRequestWindow(requestWindow),
+        });
+        if (this.rawPushRpcMethods.length > 1000)
+            this.rawPushRpcMethods = this.rawPushRpcMethods.slice(-1000);
+    }
+    rawPushRequestWindow(value) {
+        const params = jsonObjectOf(value) ?? {};
+        const afterSeq = params.after_seq;
+        const limit = params.limit;
+        // 仅返回恢复窗口元数据；不得将 RPC params（其中可能含正文）暴露给测试接口。
+        return {
+            window_mode: typeof params.window_mode === 'string' ? params.window_mode : '',
+            after_seq: typeof afterSeq === 'number' && Number.isInteger(afterSeq) ? afterSeq : null,
+            limit: typeof limit === 'number' && Number.isInteger(limit) ? limit : null,
+        };
     }
     async close() {
         try {
@@ -173,7 +289,7 @@ class CrossSdkJsAgent {
             verifySsl: false,
         });
     }
-    async ensureConnected() {
+    async ensureConnected(backgroundSync = true) {
         const store = this.aidStore();
         try {
             const registered = await store.register(this.aid);
@@ -187,12 +303,29 @@ class CrossSdkJsAgent {
             if (!loaded.ok) {
                 throw new Error(`load identity failed: ${loaded.error.code}: ${loaded.error.message}`);
             }
-            this.client.loadIdentity(loaded.data.aid);
+            let identity = loaded.data.aid;
+            if (this.debug && !identity.debug) {
+                identity = await AID.create({
+                    aid: identity.aid,
+                    aunPath: identity.aunPath,
+                    certPem: identity.certPem,
+                    privateKeyPem: identity.privateKeyPem,
+                    certValid: identity.isCertValid(),
+                    privateKeyValid: identity.isPrivateKeyValid(),
+                    deviceId: identity.deviceId,
+                    slotId: identity.slotId,
+                    verifySsl: identity.verifySsl,
+                    rootCaPath: identity.rootCaPath,
+                    debug: true,
+                });
+            }
+            this.client.loadIdentity(identity);
+            this.installTransportRpcObserver();
         }
         finally {
             store.close();
         }
-        await this.client.connect({ auto_reconnect: false, background_sync: true });
+        await this.client.connect({ auto_reconnect: false, background_sync: backgroundSync });
     }
     async identity() {
         const internal = this.client;
@@ -303,6 +436,46 @@ class CrossSdkJsAgent {
                 sendJson(res, 200, { ok: true });
                 return;
             }
+            if (req.method === 'POST' && url.pathname === '/test/raw-push/reset') {
+                const body = await readJson(req);
+                this.rawPushObservations = [];
+                this.rawPushRpcMethods = [];
+                this.groupChangedEvents = [];
+                this.rawPushObservationId = textOf(body.observation_id ?? '');
+                sendJson(res, 200, { ok: true, observation_id: this.rawPushObservationId });
+                return;
+            }
+            if (req.method === 'GET' && url.pathname === '/test/raw-push') {
+                const filters = {};
+                for (const key of ['observation_id', 'scope', 'group_id', 'kind', 'raw_event'])
+                    filters[key] = textOf(url.searchParams.get(key) ?? '');
+                const limit = Math.max(1, Math.min(Number(url.searchParams.get('limit') ?? 1000) || 1000, 1000));
+                let items = [...this.rawPushObservations];
+                for (const [key, value] of Object.entries(filters))
+                    if (value)
+                        items = items.filter((item) => textOf(item[key]) === value);
+                items = items.slice(-limit);
+                const observationId = filters.observation_id;
+                let rpcEntries = [...this.rawPushRpcMethods];
+                let groupChangedEvents = [...this.groupChangedEvents];
+                if (observationId)
+                    rpcEntries = rpcEntries.filter((item) => textOf(item.observation_id) === observationId);
+                if (observationId)
+                    groupChangedEvents = groupChangedEvents.filter((item) => textOf(item.observation_id) === observationId);
+                if (filters.group_id)
+                    groupChangedEvents = groupChangedEvents.filter((item) => textOf(item.group_id) === filters.group_id);
+                rpcEntries = rpcEntries.slice(-limit);
+                const rpcMethods = rpcEntries.map((item) => textOf(item.method));
+                const rpcMethodCounts = {};
+                for (const method of rpcMethods)
+                    rpcMethodCounts[method] = Number(rpcMethodCounts[method] ?? 0) + 1;
+                sendJson(res, 200, {
+                    ok: true, items, count: items.length, rpc_methods: rpcMethods, rpc_method_counts: rpcMethodCounts,
+                    rpc_calls: rpcEntries,
+                    group_changed_events: groupChangedEvents.slice(-limit),
+                });
+                return;
+            }
             if (req.method === 'GET' && url.pathname === '/identity') {
                 sendJson(res, 200, await this.identity());
                 return;
@@ -319,6 +492,34 @@ class CrossSdkJsAgent {
                 await this.pull(req, res);
                 return;
             }
+            if (req.method === 'GET' && url.pathname === '/sync/state') {
+                this.syncState(url, res);
+                return;
+            }
+            if (req.method === 'POST' && url.pathname === '/sync/tail') {
+                await this.syncTail(req, res);
+                return;
+            }
+            if (req.method === 'POST' && url.pathname === '/sync/forward') {
+                await this.syncForward(req, res);
+                return;
+            }
+            if (req.method === 'POST' && url.pathname === '/sync/history') {
+                await this.syncHistory(req, res);
+                return;
+            }
+            if (req.method === 'POST' && url.pathname === '/session/disconnect') {
+                await this.sessionDisconnect(res);
+                return;
+            }
+            if (req.method === 'POST' && url.pathname === '/session/connect') {
+                await this.sessionConnect(req, res);
+                return;
+            }
+            if (req.method === 'POST' && url.pathname === '/session/restart') {
+                await this.sessionRestart(req, res);
+                return;
+            }
             if (req.method === 'POST' && url.pathname === '/group/create') {
                 await this.groupCreate(req, res);
                 return;
@@ -1105,6 +1306,171 @@ class CrossSdkJsAgent {
             });
         }
     }
+    syncNamespace(scope, groupId = '') {
+        if (scope === 'p2p')
+            return `p2p:${this.aid}`;
+        if (scope === 'group' && groupId)
+            return `group:${groupId}`;
+        throw new Error('scope must be p2p, or group with group_id');
+    }
+    syncStateValue(scope, groupId = '') {
+        const namespace = this.syncNamespace(scope, groupId);
+        const tracker = this.client._seqTracker;
+        if (!tracker)
+            throw new Error('SeqTracker is unavailable');
+        return { namespace, state: tracker.getSyncState(namespace) };
+    }
+    syncState(url, res) {
+        const scope = textOf(url.searchParams.get('scope') || 'p2p').trim().toLowerCase();
+        const groupId = textOf(url.searchParams.get('group_id') || '').trim();
+        try {
+            const snapshot = this.syncStateValue(scope, groupId);
+            sendJson(res, 200, { ok: true, scope, ...snapshot });
+        }
+        catch (err) {
+            sendJson(res, 400, {
+                ok: false,
+                error_code: err instanceof Error ? err.name : 'Error',
+                error_message: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    async syncTail(req, res) {
+        await this.syncPull(req, res, true);
+    }
+    async syncForward(req, res) {
+        await this.syncPull(req, res, false);
+    }
+    async syncPull(req, res, tail) {
+        const body = await readJson(req);
+        const scope = textOf(body.scope || 'p2p').trim().toLowerCase();
+        const groupId = textOf(body.group_id || '').trim();
+        const afterSeq = Number(body.after_seq ?? 0) || 0;
+        const limit = Number(body.limit ?? 50) || 50;
+        try {
+            const params = { after_seq: afterSeq, limit };
+            if (tail)
+                params.window_mode = 'tail';
+            const method = scope === 'group' ? 'group.pull' : 'message.pull';
+            if (scope === 'group')
+                params.group_id = groupId;
+            this.syncNamespace(scope, groupId);
+            let result;
+            if (tail) {
+                result = await this.client.call(method, params);
+            }
+            else {
+                const transport = this.client._transport;
+                if (!transport?.call)
+                    throw new Error('raw transport is unavailable');
+                const wireMethod = scope === 'group' ? 'group.v2.pull' : 'message.v2.pull';
+                result = await transport.call(wireMethod, params);
+            }
+            const resultObj = jsonObjectOf(result) ?? {};
+            const messages = Array.isArray(resultObj.messages) ? resultObj.messages : [];
+            if (tail) {
+                for (const msg of messages) {
+                    if (scope === 'group')
+                        await this.storeGroupInboxItem(this.normalizeGroupMessage(msg, true));
+                    else
+                        await this.storeInboxItem(this.normalizeMessage(msg, true));
+                }
+            }
+            const snapshot = this.syncStateValue(scope, groupId);
+            sendJson(res, 200, { ok: true, scope, ...snapshot, result: jsonSafe(result) });
+        }
+        catch (err) {
+            sendJson(res, 500, {
+                ok: false,
+                scope,
+                error_code: err instanceof Error ? err.name : 'Error',
+                error_message: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    async syncHistory(req, res) {
+        const body = await readJson(req);
+        const scope = textOf(body.scope || 'p2p').trim().toLowerCase();
+        const groupId = textOf(body.group_id || '').trim();
+        const beforeSeq = Number(body.before_seq ?? 0) || 0;
+        const limit = Number(body.limit ?? 50) || 50;
+        try {
+            const params = { before_seq: beforeSeq, limit };
+            const method = scope === 'group' ? 'group.history' : 'message.history';
+            if (scope === 'group')
+                params.group_id = groupId;
+            this.syncNamespace(scope, groupId);
+            const result = await this.client.call(method, params);
+            const snapshot = this.syncStateValue(scope, groupId);
+            sendJson(res, 200, { ok: true, scope, ...snapshot, result: jsonSafe(result) });
+        }
+        catch (err) {
+            sendJson(res, 500, {
+                ok: false,
+                scope,
+                error_code: err instanceof Error ? err.name : 'Error',
+                error_message: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    async sessionDisconnect(res) {
+        try {
+            this.ready = false;
+            await this.client.disconnect();
+            sendJson(res, 200, { ok: true, state: textOf(this.client.state) });
+        }
+        catch (err) {
+            sendJson(res, 500, {
+                ok: false,
+                error_code: err instanceof Error ? err.name : 'Error',
+                error_message: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    async sessionConnect(req, res) {
+        const body = await readJson(req);
+        const backgroundSync = body.background_sync === true;
+        if (Object.prototype.hasOwnProperty.call(body, 'inline_realtime_payload_v1')) {
+            this.inlineRealtimePayloadV1 = body.inline_realtime_payload_v1 !== false;
+        }
+        try {
+            await this.client.connect({ auto_reconnect: false, background_sync: backgroundSync });
+            this.ready = true;
+            sendJson(res, 200, { ok: true, background_sync: backgroundSync, inline_realtime_payload_v1: this.inlineRealtimePayloadV1 });
+        }
+        catch (err) {
+            sendJson(res, 500, {
+                ok: false,
+                error_code: err instanceof Error ? err.name : 'Error',
+                error_message: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    async sessionRestart(req, res) {
+        const body = await readJson(req);
+        const backgroundSync = body.background_sync === true;
+        if (Object.prototype.hasOwnProperty.call(body, 'inline_realtime_payload_v1')) {
+            this.inlineRealtimePayloadV1 = body.inline_realtime_payload_v1 !== false;
+        }
+        this.ready = false;
+        try {
+            await this.client.close();
+            this.client = this.newClient();
+            this.bindClientEvents();
+            await this.ensureConnected(backgroundSync);
+            this.startupError = '';
+            this.ready = true;
+            sendJson(res, 200, { ok: true, background_sync: backgroundSync, inline_realtime_payload_v1: this.inlineRealtimePayloadV1 });
+        }
+        catch (err) {
+            this.startupError = `${err instanceof Error ? err.name : 'Error'}: ${err instanceof Error ? err.message : String(err)}`;
+            sendJson(res, 500, {
+                ok: false,
+                error_code: err instanceof Error ? err.name : 'Error',
+                error_message: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
     async groupCreate(req, res) {
         const body = await readJson(req);
         const traceId = textOf(body.trace_id || crypto.randomUUID().replace(/-/g, ''));