@foxden-app/foxclaw 0.4.16 → 0.5.0

package/dist/auth/cross_node_sync.js

@@ -6,6 +6,7 @@ import { isAuthCandidateName, parseChatGptAuthMetadata } from './mirror.js';
 const ENVELOPE_MAGIC = 'foxclaw-auth-sync';
 const NONCE_RETENTION_MS = 7 * 24 * 60 * 60_000;
 const PULL_TIMEOUT_MS = 12_000;
+const TEST_TIMEOUT_MS = 8_000;
 const LEASE_TIMEOUT_MS = 8_000;
 const LEASE_TTL_MS = 60_000;
 const REMOTE_ACCESS_TOKEN_MIN_TTL_MS = 60_000;
@@ -21,10 +22,12 @@ export class CrossNodeAuthSync {
     pendingImports = [];
     pendingPulls = new Map();
     pendingLeases = new Map();
+    pendingTests = new Map();
     seenNonces = new Map();
     timer = null;
     activeRemoteLease = null;
     activeLocalLease = null;
+    lastNotifiedError = null;
     state = {
         lastSentAt: null,
         lastReceivedAt: null,
@@ -89,6 +92,7 @@ export class CrossNodeAuthSync {
             enabled: this.config.enabled,
             nodeId: this.nodeId,
             transport: this.config.transport,
+            transportLabel: this.config.transportLabel?.trim() || null,
             peers: this.peers,
             pendingImports: this.pendingImports.length,
             lastSentAt: this.state.lastSentAt,
@@ -104,7 +108,8 @@ export class CrossNodeAuthSync {
     isIdle() {
         return this.pendingImports.length === 0
             && this.pendingPulls.size === 0
-            && this.pendingLeases.size === 0;
+            && this.pendingLeases.size === 0
+            && this.pendingTests.size === 0;
     }
     async publishCandidate(candidateName) {
         if (!this.isReady())
@@ -112,10 +117,24 @@ export class CrossNodeAuthSync {
         const record = await this.callbacks.readLocalCandidate(candidateName);
         if (!record)
             return false;
-        await this.sendToAll({
-            kind: 'push.bundle',
-            ...bundleFromRecord(record),
-        });
+        this.notify({ kind: 'candidate_publish_started', candidateName, peers: [...this.peers] });
+        try {
+            await this.sendToAll({
+                kind: 'push.bundle',
+                ...bundleFromRecord(record),
+            });
+            this.notify({ kind: 'candidate_publish_completed', candidateName, peers: [...this.peers] });
+        }
+        catch (error) {
+            this.recordError(`candidate publish failed for ${candidateName}: ${formatError(error)}`, false);
+            this.notify({
+                kind: 'candidate_publish_failed',
+                candidateName,
+                peers: [...this.peers],
+                reason: formatError(error),
+            });
+            throw error;
+        }
         return true;
     }
     async pushAll() {
@@ -123,18 +142,34 @@ export class CrossNodeAuthSync {
             return { sent: 0, skipped: 0 };
         let sent = 0;
         let skipped = 0;
-        for (const record of await this.callbacks.listLocalCandidates()) {
-            if (!isAuthCandidateName(record.candidateName)) {
-                skipped += 1;
-                continue;
+        const records = await this.callbacks.listLocalCandidates();
+        this.notify({ kind: 'push_all_started', candidateCount: records.length, peers: [...this.peers] });
+        try {
+            for (const record of records) {
+                if (!isAuthCandidateName(record.candidateName)) {
+                    skipped += 1;
+                    continue;
+                }
+                await this.sendToAll({
+                    kind: 'push.bundle',
+                    ...bundleFromRecord(record),
+                });
+                sent += 1;
             }
-            await this.sendToAll({
-                kind: 'push.bundle',
-                ...bundleFromRecord(record),
+            this.notify({ kind: 'push_all_completed', sent, skipped, peers: [...this.peers] });
+            return { sent, skipped };
+        }
+        catch (error) {
+            this.recordError(`push all failed: ${formatError(error)}`, false);
+            this.notify({
+                kind: 'push_all_failed',
+                sent,
+                skipped,
+                peers: [...this.peers],
+                reason: formatError(error),
             });
-            sent += 1;
+            throw error;
         }
-        return { sent, skipped };
     }
     async publishDigest() {
         if (!this.isReady())
@@ -150,18 +185,28 @@ export class CrossNodeAuthSync {
         if (!this.isReady() || !isAuthCandidateName(candidateName))
             return false;
         const requestId = crypto.randomUUID();
+        const peers = [...this.peers];
+        this.notify({ kind: 'recovery_started', candidateName, peers });
         const result = await new Promise((resolve) => {
             const timer = setTimeout(() => {
                 const pending = this.pendingPulls.get(requestId);
                 if (pending) {
                     pending.finished = true;
                     this.pendingPulls.delete(requestId);
+                    this.notify({
+                        kind: 'recovery_failed',
+                        candidateName,
+                        peers,
+                        reason: `timed out waiting for ${this.peers.length} auth sync peer response(s)`,
+                    });
                     resolve(false);
                 }
             }, PULL_TIMEOUT_MS);
             timer.unref();
             this.pendingPulls.set(requestId, {
                 candidateName,
+                peers,
+                emptyReplies: new Map(),
                 resolve,
                 timer,
                 finished: false,
@@ -175,7 +220,13 @@ export class CrossNodeAuthSync {
             }).catch((error) => {
                 clearTimeout(timer);
                 this.pendingPulls.delete(requestId);
-                this.recordError(`pull request failed: ${formatError(error)}`);
+                this.recordError(`pull request failed: ${formatError(error)}`, false);
+                this.notify({
+                    kind: 'recovery_failed',
+                    candidateName,
+                    peers: [...this.peers],
+                    reason: formatError(error),
+                });
                 resolve(false);
             });
         });
@@ -240,9 +291,37 @@ export class CrossNodeAuthSync {
     }
     async testPeers() {
         if (!this.isReady())
-            return { sent: 0 };
-        await this.sendToAll({ kind: 'test.ping', requestId: crypto.randomUUID() });
-        return { sent: this.peers.length };
+            return { sent: 0, replied: 0, missing: [] };
+        const requestId = crypto.randomUUID();
+        const peers = [...this.peers];
+        const resultPromise = new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.finishPendingTest(requestId);
+            }, TEST_TIMEOUT_MS);
+            timer.unref();
+            this.pendingTests.set(requestId, {
+                peers,
+                replies: new Set(),
+                resolve,
+                timer,
+                finished: false,
+            });
+        });
+        try {
+            await this.sendToAll({ kind: 'test.ping', requestId });
+        }
+        catch (error) {
+            const pending = this.pendingTests.get(requestId);
+            if (pending) {
+                clearTimeout(pending.timer);
+                this.pendingTests.delete(requestId);
+            }
+            throw error;
+        }
+        if (peers.length === 0) {
+            this.finishPendingTest(requestId);
+        }
+        return resultPromise;
     }
     async handleIncomingEnvelope(rawEnvelope, peer) {
         if (!this.isReady() || !this.isAllowedPeer(peer)) {
@@ -269,7 +348,7 @@ export class CrossNodeAuthSync {
                 this.enqueueImport(message, senderNodeId, sourceLabel, normalizePeerIdentity(peer));
                 return;
             case 'pull.request':
-                await this.handlePullRequest(message, normalizePeerIdentity(peer));
+                await this.handlePullRequest(message, senderNodeId, normalizePeerIdentity(peer));
                 return;
             case 'pull.response':
                 await this.handlePullResponse(message, senderNodeId, sourceLabel, normalizePeerIdentity(peer));
@@ -285,6 +364,7 @@ export class CrossNodeAuthSync {
                 });
                 return;
             case 'test.pong':
+                this.handleTestPong(message.requestId, normalizePeerIdentity(peer));
                 this.logger.info('auth.sync.test_pong', { peer: normalizePeerIdentity(peer), nodeId: message.nodeId });
                 return;
             case 'lease.request':
@@ -303,20 +383,47 @@ export class CrossNodeAuthSync {
                 return;
         }
     }
-    async handlePullRequest(message, peer) {
+    async handlePullRequest(message, requesterNodeId, peer) {
         if (!isAuthCandidateName(message.candidateName))
             return;
+        this.notify({
+            kind: 'pull_request_received',
+            candidateName: message.candidateName,
+            peer,
+            requesterNodeId,
+        });
         const record = await this.callbacks.readLocalCandidate(message.candidateName);
         if (!record) {
             await this.sendToPeer(peer, { kind: 'pull.response', requestId: message.requestId, bundle: null, reason: 'candidate not found' });
+            this.notify({
+                kind: 'pull_response_sent',
+                candidateName: message.candidateName,
+                peer,
+                result: 'candidate_not_found',
+                reason: 'candidate not found',
+            });
             return;
         }
         if (message.accountId && record.accountId !== message.accountId) {
             await this.sendToPeer(peer, { kind: 'pull.response', requestId: message.requestId, bundle: null, reason: 'account mismatch' });
+            this.notify({
+                kind: 'pull_response_sent',
+                candidateName: message.candidateName,
+                peer,
+                result: 'account_mismatch',
+                reason: 'account mismatch',
+            });
             return;
         }
         if (message.lastRefreshMs !== null && record.lastRefreshMs <= message.lastRefreshMs) {
             await this.sendToPeer(peer, { kind: 'pull.response', requestId: message.requestId, bundle: null, reason: 'not newer' });
+            this.notify({
+                kind: 'pull_response_sent',
+                candidateName: message.candidateName,
+                peer,
+                result: 'not_newer',
+                reason: 'not newer',
+            });
             return;
         }
         await this.sendToPeer(peer, {
@@ -324,22 +431,68 @@ export class CrossNodeAuthSync {
             requestId: message.requestId,
             bundle: bundleFromRecord(record),
         });
+        this.notify({
+            kind: 'pull_response_sent',
+            candidateName: message.candidateName,
+            peer,
+            result: 'sent',
+            reason: null,
+        });
     }
     async handlePullResponse(message, senderNodeId, sourceLabel, peer) {
         const pending = this.pendingPulls.get(message.requestId);
         if (!pending || pending.finished)
             return;
+        const matchedPeer = this.matchConfiguredPeer(peer) ?? peer;
         if (!message.bundle || message.bundle.candidateName !== pending.candidateName) {
+            const reason = message.reason ?? 'peer did not return a matching candidate';
+            this.notify({
+                kind: 'recovery_peer_empty',
+                candidateName: pending.candidateName,
+                peer,
+                reason,
+            });
+            this.markPullPeerUnavailable(message.requestId, matchedPeer, reason);
             return;
         }
-        const imported = await this.validateAndImport(message.bundle, senderNodeId, sourceLabel, peer);
-        if (!imported)
+        this.notify({
+            kind: 'recovery_peer_bundle_received',
+            candidateName: pending.candidateName,
+            peer,
+            sourceNodeId: senderNodeId,
+        });
+        const outcome = await this.validateAndImport(message.bundle, senderNodeId, sourceLabel, peer, 'pull');
+        if (!outcome.imported) {
+            this.markPullPeerUnavailable(message.requestId, matchedPeer, outcome.reason ?? 'peer candidate was not imported');
             return;
+        }
         pending.finished = true;
         clearTimeout(pending.timer);
         this.pendingPulls.delete(message.requestId);
         pending.resolve(true);
     }
+    markPullPeerUnavailable(requestId, peer, reason) {
+        const pending = this.pendingPulls.get(requestId);
+        if (!pending || pending.finished)
+            return;
+        pending.emptyReplies.set(peer, reason);
+        if (!pending.peers.every(peerName => pending.emptyReplies.has(peerName))) {
+            return;
+        }
+        pending.finished = true;
+        clearTimeout(pending.timer);
+        this.pendingPulls.delete(requestId);
+        const details = pending.peers
+            .map(peerName => `${peerName}: ${pending.emptyReplies.get(peerName) ?? 'no usable candidate'}`)
+            .join('; ');
+        this.notify({
+            kind: 'recovery_failed',
+            candidateName: pending.candidateName,
+            peers: pending.peers,
+            reason: `all peers replied without an importable auth candidate${details ? ` (${details})` : ''}`,
+        });
+        pending.resolve(false);
+    }
     async handleDigest(message, peer) {
         const remote = new Map(message.records.map(record => [record.candidateName, record]));
         for (const local of await this.callbacks.listLocalCandidates()) {
@@ -395,6 +548,7 @@ export class CrossNodeAuthSync {
         }
     }
     enqueueImport(bundle, sourceNodeId, sourceLabel, fromPeer) {
+        const queued = !this.callbacks.isIdle() || this.pendingImports.length > 0;
         this.pendingImports.push({
             bundle,
             sourceNodeId,
@@ -402,6 +556,15 @@ export class CrossNodeAuthSync {
             receivedAt: Date.now(),
             fromPeer,
         });
+        this.notify({
+            kind: 'remote_bundle_received',
+            candidateName: bundle.candidateName,
+            sourceNodeId,
+            sourceLabel: sourceLabel ?? fromPeer,
+            peer: fromPeer,
+            queued,
+            queueLength: this.pendingImports.length,
+        });
         void this.processPendingImports().catch((error) => {
             this.recordError(`remote import failed: ${formatError(error)}`);
         });
@@ -411,40 +574,35 @@ export class CrossNodeAuthSync {
             return;
         while (this.pendingImports.length > 0 && this.callbacks.isIdle()) {
             const pending = this.pendingImports.shift();
-            await this.validateAndImport(pending.bundle, pending.sourceNodeId, pending.sourceLabel, pending.fromPeer);
+            await this.validateAndImport(pending.bundle, pending.sourceNodeId, pending.sourceLabel, pending.fromPeer, 'push');
         }
     }
-    async validateAndImport(bundle, sourceNodeId, sourceLabel, fromPeer) {
+    async validateAndImport(bundle, sourceNodeId, sourceLabel, fromPeer, mode) {
+        const source = sourceLabel ?? fromPeer;
         if (!isValidBundle(bundle)) {
-            this.recordError('remote bundle shape is invalid');
-            return false;
+            return this.rejectImport(bundle, sourceNodeId, source, fromPeer, mode, 'remote bundle shape is invalid');
         }
         const metadata = parseChatGptAuthMetadata(bundle.rawAuth);
         if (!metadata || metadata.accountId !== bundle.accountId || metadata.lastRefreshMs !== bundle.lastRefreshMs) {
-            this.recordError(`remote bundle metadata mismatch for ${bundle.candidateName}`);
-            return false;
+            return this.rejectImport(bundle, sourceNodeId, source, fromPeer, mode, `remote bundle metadata mismatch for ${bundle.candidateName}`);
         }
         if (sha256(bundle.rawAuth) !== bundle.authSha256) {
-            this.recordError(`remote bundle hash mismatch for ${bundle.candidateName}`);
-            return false;
+            return this.rejectImport(bundle, sourceNodeId, source, fromPeer, mode, `remote bundle hash mismatch for ${bundle.candidateName}`);
         }
         const expiresAt = readAccessTokenExpiresAtMs(bundle.rawAuth);
         if (expiresAt === null || expiresAt <= Date.now() + REMOTE_ACCESS_TOKEN_MIN_TTL_MS) {
-            this.recordError(`remote access token is expired or missing exp for ${bundle.candidateName}`);
-            return false;
+            return this.rejectImport(bundle, sourceNodeId, source, fromPeer, mode, `remote access token is expired or missing exp for ${bundle.candidateName}`);
         }
         const validation = await this.callbacks.validateCandidate(bundle.candidateName, bundle.rawAuth, bundle.accountId);
         if (!validation.ok) {
-            this.recordError(`remote candidate validation failed for ${bundle.candidateName}: ${validation.reason ?? 'unknown'}`);
-            return false;
+            return this.rejectImport(bundle, sourceNodeId, source, fromPeer, mode, `remote candidate validation failed for ${bundle.candidateName}: ${validation.reason ?? 'unknown'}`);
         }
         const result = await this.callbacks.importCandidate(bundle.candidateName, bundle.rawAuth, {
             nodeId: sourceNodeId,
-            label: sourceLabel ?? fromPeer,
+            label: source,
         });
         if (!result.ok) {
-            this.recordError(`remote candidate import failed for ${bundle.candidateName}: ${result.reason ?? 'unknown'}`);
-            return false;
+            return this.rejectImport(bundle, sourceNodeId, source, fromPeer, mode, `remote candidate import failed for ${bundle.candidateName}: ${result.reason ?? 'unknown'}`);
         }
         if (result.imported) {
             this.state.lastImportedAt = new Date().toISOString();
@@ -452,8 +610,27 @@ export class CrossNodeAuthSync {
             this.state.lastError = null;
             await this.writeState();
             this.logger.info('auth.sync.imported', { candidateName: bundle.candidateName, sourceNodeId });
+            this.notify({
+                kind: 'remote_import_imported',
+                candidateName: bundle.candidateName,
+                sourceNodeId,
+                sourceLabel: source,
+                peer: fromPeer,
+                mode,
+            });
         }
-        return result.imported;
+        else {
+            this.notify({
+                kind: 'remote_import_skipped',
+                candidateName: bundle.candidateName,
+                sourceNodeId,
+                sourceLabel: source,
+                peer: fromPeer,
+                mode,
+                reason: result.reason ?? 'local candidate did not need an update',
+            });
+        }
+        return { ok: true, imported: result.imported, reason: result.reason ?? null };
     }
     async sendToAll(message) {
         await Promise.all(this.peers.map(peer => this.sendToPeer(peer, message)));
@@ -462,8 +639,35 @@ export class CrossNodeAuthSync {
         const envelope = this.sealEnvelope(message);
         await this.transport.send(peer, envelope);
         this.state.lastSentAt = new Date().toISOString();
+        if (this.state.lastError?.includes('USER_BOT_TO_BOT_DISABLED')) {
+            this.state.lastError = null;
+        }
         await this.writeState();
     }
+    handleTestPong(requestId, peer) {
+        const pending = this.pendingTests.get(requestId);
+        if (!pending || pending.finished)
+            return;
+        const matchedPeer = this.matchConfiguredPeer(peer) ?? peer;
+        pending.replies.add(matchedPeer);
+        if (pending.peers.every(peerName => pending.replies.has(peerName))) {
+            this.finishPendingTest(requestId);
+        }
+    }
+    finishPendingTest(requestId) {
+        const pending = this.pendingTests.get(requestId);
+        if (!pending || pending.finished)
+            return;
+        pending.finished = true;
+        clearTimeout(pending.timer);
+        this.pendingTests.delete(requestId);
+        const missing = pending.peers.filter(peer => !pending.replies.has(peer));
+        pending.resolve({
+            sent: pending.peers.length,
+            replied: pending.replies.size,
+            missing,
+        });
+    }
     sealEnvelope(message) {
         if (!this.key || !this.nodeId) {
             throw new Error('auth sync is not initialized');
@@ -528,6 +732,10 @@ export class CrossNodeAuthSync {
         ];
         return keys.some(key => this.peerKeys.has(key));
     }
+    matchConfiguredPeer(peer) {
+        const keys = new Set(expandPeerKeys(peer));
+        return this.peers.find(configuredPeer => expandPeerKeys(configuredPeer).some(key => keys.has(key))) ?? null;
+    }
     expireLeases() {
         const now = Date.now();
         if (this.activeRemoteLease && this.activeRemoteLease.expiresAt <= now) {
@@ -537,12 +745,41 @@ export class CrossNodeAuthSync {
             this.activeLocalLease = null;
         }
     }
-    recordError(message) {
+    recordError(message, notify = true) {
         this.state.lastError = message;
         this.logger.warn('auth.sync.error', { error: message });
         void this.writeState().catch((error) => {
             this.logger.warn('auth.sync.state_write_failed', { error: formatError(error) });
         });
+        if (notify) {
+            this.notifyError(message);
+        }
+    }
+    rejectImport(bundle, sourceNodeId, sourceLabel, fromPeer, mode, reason) {
+        this.recordError(reason, false);
+        this.notify({
+            kind: 'remote_import_failed',
+            candidateName: bundle.candidateName,
+            sourceNodeId,
+            sourceLabel,
+            peer: fromPeer,
+            mode,
+            reason,
+        });
+        return { ok: false, imported: false, reason };
+    }
+    notify(event) {
+        if (!this.callbacks.notify)
+            return;
+        void this.callbacks.notify(event).catch((error) => {
+            this.logger.warn('auth.sync.notify_failed', { error: formatError(error) });
+        });
+    }
+    notifyError(reason) {
+        if (this.lastNotifiedError === reason)
+            return;
+        this.lastNotifiedError = reason;
+        this.notify({ kind: 'sync_error', reason });
     }
     async writeState() {
         if (!this.config.enabled)

package/dist/controller/controller.d.ts

@@ -23,6 +23,8 @@ export interface CoreCoordinator {
     }>;
     authSyncTest?: () => Promise<{
         sent: number;
+        replied: number;
+        missing: string[];
     }>;
     statusUpdated?: (status: RuntimeStatus) => void;
     getServiceStatus?: () => Promise<{

package/dist/controller/controller.js

@@ -430,6 +430,7 @@ export class BridgeSessionCore {
                     if (serviceStatus.authSync?.enabled) {
                         lines.push(t(locale, 'status_auth_sync', {
                             node: serviceStatus.authSync.nodeId ?? t(locale, 'unknown'),
+                            contact: serviceStatus.authSync.transportLabel ?? t(locale, 'unknown'),
                             peers: serviceStatus.authSync.peers.length,
                             pending: serviceStatus.authSync.pendingImports,
                         }));
@@ -4009,7 +4010,11 @@ export class BridgeSessionCore {
                 await this.sendMessage(scopeId, t(locale, 'auth_sync_disabled'));
                 return;
             }
-            await this.sendMessage(scopeId, t(locale, 'auth_sync_test_sent', { count: result.sent }));
+            const message = [
+                t(locale, 'auth_sync_test_sent', { sent: result.sent, replied: result.replied }),
+                ...(result.missing.length > 0 ? [t(locale, 'auth_sync_test_missing', { value: result.missing.join(', ') })] : []),
+            ].join('\n');
+            await this.sendMessage(scopeId, message);
             return;
         }
         if (action === 'push' && args[1]?.toLowerCase() === 'all') {
@@ -8117,6 +8122,7 @@ function formatAuthSyncStatus(locale, status) {
     const lines = [
         t(locale, 'auth_sync_status_title'),
         t(locale, 'auth_sync_status_node', { value: status.nodeId ?? t(locale, 'unknown') }),
+        t(locale, 'auth_sync_status_transport', { value: status.transportLabel ?? t(locale, 'unknown') }),
         t(locale, 'auth_sync_status_peers', { value: status.peers.length === 0 ? t(locale, 'none') : status.peers.join(', ') }),
         t(locale, 'auth_sync_status_pending', { value: status.pendingImports }),
         t(locale, 'auth_sync_status_sent', { value: status.lastSentAt ?? t(locale, 'none') }),

package/dist/i18n.d.ts

@@ -125,7 +125,7 @@ declare const MESSAGES: {
         readonly status_runtime_weixin: "- Weixin default runtime: connected {connected}, active turns {turns}";
         readonly status_auth_mirror_none: "Last auth mirror: none recorded";
         readonly status_auth_mirror_synced: "Last auth mirror: {candidate} from {source} at {time}";
-        readonly status_auth_sync: "Cross-node auth sync: node {node}, peers {peers}, pending imports {pending}";
+        readonly status_auth_sync: "Cross-node auth sync: node {node}, contact {contact}, peers {peers}, pending imports {pending}";
         readonly status_auth_sync_error: "Cross-node auth sync error: {value}";
         readonly status_last_update_none: "Last service update: none recorded";
         readonly status_last_update: "Last service update: {from} -> {to} at {time}";
@@ -203,11 +203,13 @@ declare const MESSAGES: {
         readonly auth_add_reverted: "Restored previous auth.";
         readonly auth_add_missing_file: "Login completed, but the new auth file was not created: {value}";
         readonly auth_sync_disabled: "Cross-node auth sync is disabled.";
-        readonly auth_sync_test_sent: "Auth sync test ping sent to {count} peer(s).";
+        readonly auth_sync_test_sent: "Auth sync test complete: sent {sent}, replies {replied}.";
+        readonly auth_sync_test_missing: "Missing replies: {value}";
         readonly auth_sync_push_blocked_active: "Cannot push auth sync while any runtime, approval, input, login, or auth mirror write is active.";
         readonly auth_sync_push_done: "Auth sync push complete: sent {sent}, skipped {skipped}.";
         readonly auth_sync_status_title: "Cross-node auth sync:";
         readonly auth_sync_status_node: "Node: {value}";
+        readonly auth_sync_status_transport: "Contact bot: {value}";
         readonly auth_sync_status_peers: "Peers: {value}";
         readonly auth_sync_status_pending: "Pending imports: {value}";
         readonly auth_sync_status_sent: "Last sent: {value}";
@@ -750,7 +752,7 @@ declare const MESSAGES: {
         readonly status_runtime_weixin: "- 微信默认运行时：连接 {connected}，进行中回复 {turns}";
         readonly status_auth_mirror_none: "最近 auth 镜像：暂无记录";
         readonly status_auth_mirror_synced: "最近 auth 镜像：{candidate} 由 {source} 于 {time} 同步";
-        readonly status_auth_sync: "跨节点 auth 同步：节点 {node}，peer {peers}，待导入 {pending}";
+        readonly status_auth_sync: "跨节点 auth 同步：节点 {node}，联系人 {contact}，peer {peers}，待导入 {pending}";
         readonly status_auth_sync_error: "跨节点 auth 同步错误：{value}";
         readonly status_last_update_none: "最近服务升级：暂无记录";
         readonly status_last_update: "最近服务升级：{from} -> {to}（{time}）";
@@ -828,11 +830,13 @@ declare const MESSAGES: {
         readonly auth_add_reverted: "已恢复之前的 auth。";
         readonly auth_add_missing_file: "登录已完成，但没有创建新的 auth 文件：{value}";
         readonly auth_sync_disabled: "跨节点 auth 同步未启用。";
-        readonly auth_sync_test_sent: "已向 {count} 个 peer 发送 auth sync 测试 ping。";
+        readonly auth_sync_test_sent: "auth sync 测试完成：已发送 {sent}，收到回应 {replied}。";
+        readonly auth_sync_test_missing: "未回应：{value}";
         readonly auth_sync_push_blocked_active: "当前有任一 runtime、审批、待输入、登录或 auth 镜像写入在进行中，不能推送 auth 同步。";
         readonly auth_sync_push_done: "auth 同步推送完成：已发送 {sent}，已跳过 {skipped}。";
         readonly auth_sync_status_title: "跨节点 auth 同步：";
         readonly auth_sync_status_node: "节点：{value}";
+        readonly auth_sync_status_transport: "联系人 bot：{value}";
         readonly auth_sync_status_peers: "Peer：{value}";
         readonly auth_sync_status_pending: "待导入：{value}";
         readonly auth_sync_status_sent: "最近发送：{value}";

package/dist/i18n.js

@@ -123,7 +123,7 @@ const MESSAGES = {
         status_runtime_weixin: '- Weixin default runtime: connected {connected}, active turns {turns}',
         status_auth_mirror_none: 'Last auth mirror: none recorded',
         status_auth_mirror_synced: 'Last auth mirror: {candidate} from {source} at {time}',
-        status_auth_sync: 'Cross-node auth sync: node {node}, peers {peers}, pending imports {pending}',
+        status_auth_sync: 'Cross-node auth sync: node {node}, contact {contact}, peers {peers}, pending imports {pending}',
         status_auth_sync_error: 'Cross-node auth sync error: {value}',
         status_last_update_none: 'Last service update: none recorded',
         status_last_update: 'Last service update: {from} -> {to} at {time}',
@@ -201,11 +201,13 @@ const MESSAGES = {
         auth_add_reverted: 'Restored previous auth.',
         auth_add_missing_file: 'Login completed, but the new auth file was not created: {value}',
         auth_sync_disabled: 'Cross-node auth sync is disabled.',
-        auth_sync_test_sent: 'Auth sync test ping sent to {count} peer(s).',
+        auth_sync_test_sent: 'Auth sync test complete: sent {sent}, replies {replied}.',
+        auth_sync_test_missing: 'Missing replies: {value}',
         auth_sync_push_blocked_active: 'Cannot push auth sync while any runtime, approval, input, login, or auth mirror write is active.',
         auth_sync_push_done: 'Auth sync push complete: sent {sent}, skipped {skipped}.',
         auth_sync_status_title: 'Cross-node auth sync:',
         auth_sync_status_node: 'Node: {value}',
+        auth_sync_status_transport: 'Contact bot: {value}',
         auth_sync_status_peers: 'Peers: {value}',
         auth_sync_status_pending: 'Pending imports: {value}',
         auth_sync_status_sent: 'Last sent: {value}',
@@ -748,7 +750,7 @@ const MESSAGES = {
         status_runtime_weixin: '- 微信默认运行时：连接 {connected}，进行中回复 {turns}',
         status_auth_mirror_none: '最近 auth 镜像：暂无记录',
         status_auth_mirror_synced: '最近 auth 镜像：{candidate} 由 {source} 于 {time} 同步',
-        status_auth_sync: '跨节点 auth 同步：节点 {node}，peer {peers}，待导入 {pending}',
+        status_auth_sync: '跨节点 auth 同步：节点 {node}，联系人 {contact}，peer {peers}，待导入 {pending}',
         status_auth_sync_error: '跨节点 auth 同步错误：{value}',
         status_last_update_none: '最近服务升级：暂无记录',
         status_last_update: '最近服务升级：{from} -> {to}（{time}）',
@@ -826,11 +828,13 @@ const MESSAGES = {
         auth_add_reverted: '已恢复之前的 auth。',
         auth_add_missing_file: '登录已完成，但没有创建新的 auth 文件：{value}',
         auth_sync_disabled: '跨节点 auth 同步未启用。',
-        auth_sync_test_sent: '已向 {count} 个 peer 发送 auth sync 测试 ping。',
+        auth_sync_test_sent: 'auth sync 测试完成：已发送 {sent}，收到回应 {replied}。',
+        auth_sync_test_missing: '未回应：{value}',
         auth_sync_push_blocked_active: '当前有任一 runtime、审批、待输入、登录或 auth 镜像写入在进行中，不能推送 auth 同步。',
         auth_sync_push_done: 'auth 同步推送完成：已发送 {sent}，已跳过 {skipped}。',
         auth_sync_status_title: '跨节点 auth 同步：',
         auth_sync_status_node: '节点：{value}',
+        auth_sync_status_transport: '联系人 bot：{value}',
         auth_sync_status_peers: 'Peer：{value}',
         auth_sync_status_pending: '待导入：{value}',
         auth_sync_status_sent: '最近发送：{value}',