egos-transfer 0.2.5 → 0.2.6

package/dist/index.js

@@ -33,117 +33,45 @@ const entity_1 = require("./entity");
 const router_1 = require("./router");
 const axios_1 = __importDefault(require("axios"));
 const delay_1 = __importDefault(require("delay"));
-/** 重连退避相关常量 */
-const MAX_RECONNECT_BACKOFF = 30000; // 最大退避 30s
-const BASE_RECONNECT_BACKOFF = 1000; // 基础退避 1s
+const MAX_RECONNECT_BACKOFF = 30000;
+const BASE_RECONNECT_BACKOFF = 1000;
 class PeerTransfer {
-    constructor(deviceId, config, isRandomPeerId = false) {
-        this.checkerId = null;
-        /** 重连尝试次数，成功连接后归零 */
-        this.reconnectAttempt = 0;
-        /** 标记实例已销毁，防止异步操作继续 */
-        this.destroyed = false;
-        /** 按 requestId 追踪进行中的请求 */
-        this.inRequest = new Map();
+    constructor(deviceId, config) {
         this.connectPool = new Map();
-        this.peerConfig = Object.assign(Object.assign({}, config), { key: String(Date.now()) });
         this.requests = new Map();
-        this.requestTimers = new Map();
-        this.timeout = entity_1.REQUEST_TIMEOUT;
         this.router = new router_1.PeerRouter();
-        this.isPaused = false;
-        this.peerId = isRandomPeerId ? deviceId + '_' + Date.now() : deviceId;
+        this.reconnectAttempt = 0;
+        this.destroyed = false;
+        /** connectionId → Set<requestId> — settle in-flight requests on connection drop */
+        this.connRequests = new Map();
+        this._reconnecting = false;
+        this.peerConfig = Object.assign(Object.assign({}, config), { key: String(Date.now()) });
+        this.peerId = deviceId;
         this.deviceId = deviceId;
     }
+    // ── Peer lifecycle ──────────────────────────────────────────────
     createPeer() {
-        return __awaiter(this, arguments, void 0, function* (force = false) {
+        return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            console.log('createPeer', this.isPaused, force);
-            if (this.isPaused && !force) {
-                return;
-            }
-            if (this.booted) {
-                return this.booted;
-            }
-            if (((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open) && !force) {
+            if (this.destroyed)
+                throw new Error('destroyed');
+            if ((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open)
                 return this.peer;
-            }
-            this.destroy();
-            yield (0, delay_1.default)(1500);
+            this.destroyPeer();
             yield this.reloadConfig();
             const peer = new peerjs_1.Peer(this.peerId, Object.assign(Object.assign({}, this.peerConfig), { pingInterval: 9000 }));
             this.peer = peer;
-            yield this.initialize(this.peer);
-            this.checkConnection();
-            this.destroyed = false;
-            return this.peer;
-        });
-    }
-    initialize(peer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.checkerId) {
-                clearInterval(this.checkerId);
-                this.checkerId = null;
-            }
-            if (this.booted) {
-                return this.booted;
-            }
-            this.booted = new Promise((resolve) => {
-                const timer = setTimeout(() => {
-                    resolve(null);
-                }, constant_1.PEER_OPEN_TIMEOUT);
-                const done = (p) => {
-                    clearTimeout(timer);
-                    resolve(p);
-                };
-                peer.once('open', (id) => {
-                    console.log('peer@open');
-                    this.reconnectAttempt = 0; // 连接成功，重置退避计数
-                    done(peer);
-                });
-                // peer.on('disconnected', () => {
-                //   if (!this.isPaused) {
-                //     this.reconnect();
-                //   }
-                // });
-                peer.on('close', () => {
-                    setTimeout(() => {
-                        if (!this.isPaused && !this.destroyed) {
-                            this.reconnect();
-                        }
-                    }, constant_1.CONNECTION_TIMEOUT);
-                });
-                peer.on('error', (err) => __awaiter(this, void 0, void 0, function* () {
-                    if (err.message === constant_1.CONNECTION_PEER_CONFLICT) {
-                        this.stop();
-                        done(null);
-                        return;
-                    }
-                    if (err.message === constant_1.CONNECTION_LIMIT_EXCEED) {
-                        this.onConnectLimit();
-                        return done(null);
-                    }
-                    if (err.message === constant_1.UNAUTHORIZED) {
-                        done(null);
-                        return this.requireAuth();
-                    }
-                    if (err.message === constant_1.CONNECTION_DUPLICATED) {
-                        // 连接级重复错误，不应销毁重建 peer
-                        // createConnection 重试循环会处理
-                        console.warn('peer@error: connection duplicated, will retry');
-                        return;
-                    }
-                    if (err.type === 'network') {
-                        done(null);
-                        return this.reconnect();
-                    }
-                    if (err.type === 'server-error') {
-                        done(null);
-                        return this.reconnect();
-                    }
-                    done(null);
-                    return this.createPeer(true);
-                }));
+            yield this.waitForOpen(peer);
+            peer.on('close', () => {
+                if (!this.destroyed)
+                    this.reconnect();
+            });
+            peer.on('error', (err) => {
+                if (this.destroyed)
+                    return;
+                if (err.type === 'network' || err.type === 'server-error') {
+                    this.reconnect();
+                }
             });
             peer.on('connection', (conn) => {
                 conn.label = 'incoming';
@@ -153,395 +81,202 @@ class PeerTransfer {
             socket === null || socket === void 0 ? void 0 : socket.on('message', (message) => {
                 this.handleSocketMessage(message);
             });
-            this.onHeartbeat({ type: 'HEARTBEAT' });
-            try {
-                yield this.booted;
-            }
-            catch (_a) {
-                // booted rejected via timer timeout
-            }
-            finally {
-                this.booted = undefined;
-            }
+            return peer;
         });
     }
-    handleSocketMessage(message) {
-        if (this.isPaused) {
-            return;
-        }
-        this.onOpen(message);
-        this.onDeviceOnline(message);
-        this.onDeviceOffline(message);
-        this.onError(message);
-        this.onHeartbeat(message);
-    }
-    onHeartbeat(message) {
-        if (message.type !== 'HEARTBEAT' || this.isPaused) {
-            return;
-        }
-    }
-    onError(message) {
-        var _a;
-        if (message.type !== 'ERROR') {
-            return;
-        }
-        if (((_a = message.payload) === null || _a === void 0 ? void 0 : _a.msg) === constant_1.CONNECTION_PEER_CONFLICT) {
-            this.stop();
-            this.getStore().dispatch({
-                type: 'global/updateNetworkState',
-                payload: {
-                    error: true,
-                    code: 'PEER_CONNECTION_CONFLICT',
-                    message: 'peer conflict',
-                },
+    waitForOpen(peer) {
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => resolve(), constant_1.PEER_OPEN_TIMEOUT);
+            peer.once('open', () => {
+                clearTimeout(timer);
+                this.reconnectAttempt = 0;
+                resolve();
             });
-        }
-    }
-    onOpen(message) {
-        if (message.type !== 'OPEN') {
-            return;
-        }
-    }
-    onDeviceOnline(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (message.type !== 'ONLINE') {
-                return;
-            }
-            this.online(message.payload.deviceId);
-        });
-    }
-    onDeviceOffline(message) {
-        if (message.type !== 'OFFLINE') {
-            return;
-        }
-        this.ping(message.payload.deviceId);
-    }
-    removeConnection(peerId, connectionId) {
-        var _a, _b, _c;
-        const conn = this.connectPool.get(peerId);
-        if (conn) {
-            if (connectionId && conn.connectionId !== connectionId) {
-                return;
-            }
-            this.connectPool.delete(peerId);
-            this.handleConnectionClose(peerId, conn);
-            conn.removeAllListeners();
-            conn.close();
-            (_a = this.peer) === null || _a === void 0 ? void 0 : _a._removeConnection(conn);
-        }
-        else {
-            const connections = ((_b = this.peer) === null || _b === void 0 ? void 0 : _b.connections) || {};
-            const conns = connections[peerId] || [];
-            if (conns.length > 0) {
-                for (const c of conns) {
-                    c.removeAllListeners();
-                    c.close();
-                    (_c = this.peer) === null || _c === void 0 ? void 0 : _c._removeConnection(c);
-                }
-            }
-        }
-    }
-    /**
-     * 连接关闭时尝试快速重连（5s 超时）：
-     * - 重连成功 → 保留 inRequest 条目，更新 conn 引用
-     * - 重连失败 → 触发 feedback 并清理 inRequest
-     */
-    handleConnectionClose(peerId, conn) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const matchedEntries = [];
-            for (const [reqId, entry] of this.inRequest) {
-                if (entry.conn.connectionId === conn.connectionId) {
-                    matchedEntries.push([reqId, entry]);
-                }
-            }
-            if (matchedEntries.length === 0) {
-                return;
-            }
-            // 快速重连，超时 5s
-            const newConn = yield Promise.race([
-                this.connectToPeer(peerId),
-                (0, delay_1.default)(5000).then(() => undefined),
-            ]);
-            if (!this.isValidConnection(newConn)) {
-                // 重连失败，触发 feedback 让请求走重试逻辑
-                for (const [reqId, entry] of matchedEntries) {
-                    entry.feedback();
-                    this.inRequest.delete(reqId);
-                }
-                return;
-            }
-            // 重连成功，更新 inRequest 中的 conn 引用
-            for (const [reqId, entry] of matchedEntries) {
-                if (this.inRequest.has(reqId)) {
-                    this.inRequest.set(reqId, Object.assign(Object.assign({}, entry), { conn: newConn }));
+            peer.once('error', (err) => {
+                if (err.message === constant_1.CONNECTION_DUPLICATED)
+                    return; // wait for open
+                clearTimeout(timer);
+                if (err.message === constant_1.CONNECTION_PEER_CONFLICT) {
+                    resolve();
+                    return;
                 }
-            }
-        });
-    }
-    addConnection(conn) {
-        this.connectPool.set(conn.peer, conn);
-        const connecting = PeerTransfer.connecting.get(conn.peer);
-        if (connecting) {
-            connecting.resolve(conn);
-        }
-    }
-    checkConnection() {
-        if (this.checkerId) {
-            clearInterval(this.checkerId);
-        }
-        this.checkerId = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (!((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open)) {
-                yield this.reconnect();
-            }
-            // turn credential expires
-            if (this.peerConfig.turnExpiredAt && this.peerConfig.turnExpiredAt - 30000 < Date.now()) {
-                yield this.reloadConfig();
-                yield this.createPeer(true);
-                return;
-            }
-            const deviceIds = Array.from(this.connectPool.keys());
-            const pingTasks = deviceIds.map((deviceId) => __awaiter(this, void 0, void 0, function* () {
-                const conn = this.connectPool.get(deviceId);
-                if (!this.isValidConnection(conn)) {
-                    this.removeConnection(conn.peer, conn.connectionId);
+                if (err.message === constant_1.CONNECTION_LIMIT_EXCEED) {
+                    this.onConnectLimit();
+                    resolve();
                     return;
                 }
-                const ok = yield this.ping(conn.peer);
-                if (!ok) {
-                    this.removeConnection(conn.peer, conn.connectionId);
+                if (err.message === constant_1.UNAUTHORIZED) {
+                    this.requireAuth();
+                    resolve();
+                    return;
                 }
-            }));
-            // 并行执行，不阻塞下个心跳周期
-            yield Promise.allSettled(pingTasks);
-        }), constant_1.HEARTBEAT_INTERVAL);
-    }
-    getApiHost() {
-        var _a, _b, _c;
-        const protocol = ((_a = this.peerConfig) === null || _a === void 0 ? void 0 : _a.secure) ? 'https' : 'http';
-        const host = ((_b = this.peerConfig) === null || _b === void 0 ? void 0 : _b.host) || 'localhost';
-        const port = ((_c = this.peerConfig) === null || _c === void 0 ? void 0 : _c.port) || 9000;
-        return `${protocol}://${host}:${port}`;
+                resolve();
+            });
+        });
     }
-    getDeviceStatus(peerId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const apiHost = this.getApiHost();
-                const res = yield axios_1.default.get(`${apiHost}/api/v1/devices/${peerId}/status`);
-                if (res.status < 400) {
-                    return res.data.data;
+    handleSocketMessage(message) {
+        var _a;
+        switch (message.type) {
+            case 'ONLINE':
+                this.online(message.payload.deviceId);
+                break;
+            case 'OFFLINE':
+                this.ping(message.payload.deviceId);
+                break;
+            case 'ERROR':
+                if (((_a = message.payload) === null || _a === void 0 ? void 0 : _a.msg) === constant_1.CONNECTION_PEER_CONFLICT) {
+                    this.getStore().dispatch({
+                        type: 'global/updateNetworkState',
+                        payload: { error: true, code: 'PEER_CONNECTION_CONFLICT', message: 'peer conflict' },
+                    });
                 }
-            }
-            catch (err) {
-                console.log('getDeviceStatus@error', err);
-            }
-        });
+                break;
+        }
     }
+    // ── Connection management ───────────────────────────────────────
     connectToPeer(peerId) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (peerId === this.deviceId) {
+            if (peerId === this.deviceId)
                 return;
-            }
-            const existingConn = this.connectPool.get(peerId);
-            console.log('connectToPeer', this.isPaused, this.connectPool.size);
-            if (existingConn) {
-                if (this.isValidConnection(existingConn)) {
-                    return existingConn;
-                }
-                else {
-                    this.removeConnection(existingConn.peer, existingConn.connectionId);
-                }
-            }
-            if (PeerTransfer.connecting.has(peerId)) {
-                const entry = PeerTransfer.connecting.get(peerId);
-                const conn = yield (entry === null || entry === void 0 ? void 0 : entry.promise);
-                if (conn) {
-                    return conn;
-                }
-            }
+            const existing = this.connectPool.get(peerId);
+            if (this.isValidConnection(existing))
+                return existing;
+            if (existing)
+                this.removeConnection(peerId, existing.connectionId);
             return this.createConnection(peerId);
         });
     }
     createConnection(peerId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const q = PeerTransfer.connecting.get(peerId);
-            if (q) {
-                return q.promise;
-            }
-            let resolve;
-            let reject;
-            const connectionPromise = new Promise((res, rej) => {
-                resolve = res;
-                reject = rej;
-            });
-            PeerTransfer.connecting.set(peerId, { promise: connectionPromise, resolve, reject });
-            // 兜底超时，防止 connecting 条目永远不清理
-            const guardTimer = setTimeout(() => {
-                PeerTransfer.connecting.delete(peerId);
-                resolve(undefined);
-            }, constant_1.CONNECTION_TIMEOUT * 3);
-            const doConnect = () => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b;
-                try {
-                    for (let retry = 0; retry < 3; retry++) {
-                        if (!this.peer) {
-                            yield this.createPeer();
-                        }
-                        if (!((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open)) {
-                            yield this.reconnect();
-                        }
-                        // 重试前检查：对方可能已经建连成功（duplicate 场景）
-                        const cur = this.connectPool.get(peerId);
-                        if (this.isValidConnection(cur)) {
-                            clearTimeout(guardTimer);
-                            return resolve(cur);
-                        }
-                        const conn = (_b = this.peer) === null || _b === void 0 ? void 0 : _b.connect(peerId, {
-                            label: 'outgoing',
-                            metadata: { time: Date.now() },
-                        });
-                        if (!conn) {
-                            continue;
-                        }
-                        const connection = yield this.onConnect(conn).catch(() => { });
-                        if (connection) {
-                            clearTimeout(guardTimer);
-                            return resolve(connection);
-                        }
-                        // duplicate 场景：onConnect 返回 undefined 但连接池可能已有对方建的连接
-                        const pooled = this.connectPool.get(peerId);
-                        if (this.isValidConnection(pooled)) {
-                            clearTimeout(guardTimer);
-                            return resolve(pooled);
-                        }
+            var _a, _b;
+            for (let retry = 0; retry < 3; retry++) {
+                if (!((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open)) {
+                    try {
+                        yield this.createPeer();
                     }
-                    clearTimeout(guardTimer);
-                    resolve(undefined);
-                    return undefined;
-                }
-                catch (err) {
-                    reject(err);
-                }
-                finally {
-                    PeerTransfer.connecting.delete(peerId);
+                    catch ( /* fall through */_c) { /* fall through */ }
                 }
-            });
-            doConnect();
-            const conn = yield connectionPromise;
-            return conn;
-        });
-    }
-    /**
-     * 心跳检测 - 直接 send，不走 request 管线，避免重试放大
-     */
-    ping(peerId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.deviceId === peerId) {
-                return;
-            }
-            const conn = this.connectPool.get(peerId);
-            if (!this.isValidConnection(conn)) {
-                this.removeConnection(peerId, conn === null || conn === void 0 ? void 0 : conn.connectionId);
-                return;
-            }
-            try {
-                const requestId = yield this.genRequestId();
-                return new Promise((resolve) => {
-                    const timer = setTimeout(() => {
-                        this.requests.delete(requestId);
-                        resolve(false);
-                    }, constant_1.PING_TIMEOUT);
-                    this.requests.set(requestId, () => {
-                        clearTimeout(timer);
-                        resolve(true);
-                    });
-                    conn.send({
-                        route: entity_1.PeerRoutes.HEARTBEAT,
-                        method: 'get',
-                        body: {},
-                        requestId,
-                        scope: entity_1.PeerScope.REQUEST,
-                        action: entity_1.PeerAction.SEND,
-                        src: this.peerId,
-                        dest: peerId,
-                        headers: {},
-                        createdAt: Date.now(),
-                    });
+                if (!((_b = this.peer) === null || _b === void 0 ? void 0 : _b.open))
+                    continue;
+                const pooled = this.connectPool.get(peerId);
+                if (this.isValidConnection(pooled))
+                    return pooled;
+                const conn = this.peer.connect(peerId, {
+                    label: 'outgoing',
+                    metadata: { time: Date.now() },
                 });
-            }
-            catch (_a) {
-                return false;
-            }
+                if (!conn)
+                    continue;
+                const result = yield this.onConnect(conn).catch(() => undefined);
+                if (result)
+                    return result;
+                const pooled2 = this.connectPool.get(peerId);
+                if (this.isValidConnection(pooled2))
+                    return pooled2;
+            }
+            return undefined;
         });
     }
     onConnect(conn) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!conn) {
+            if (!conn)
                 return;
-            }
-            const exists = this.connectPool.get(conn.peer);
-            if (exists) {
-                // 双方同时建连时，保留 peerId 字典序大的那条（确定性，不依赖时间戳）
-                if (exists.connectionId > conn.connectionId) {
+            const existing = this.connectPool.get(conn.peer);
+            if (existing) {
+                if (existing.connectionId > conn.connectionId) {
                     this.removeConnection(conn.peer, conn.connectionId);
-                    if (this.isValidConnection(exists)) {
-                        return exists;
-                    }
+                    if (this.isValidConnection(existing))
+                        return existing;
                 }
                 else {
-                    this.removeConnection(exists.peer, exists.connectionId);
+                    this.removeConnection(existing.peer, existing.connectionId);
                 }
             }
             if (conn.open) {
-                this.addConnection(conn);
-                this.bindConnectionData(conn);
+                this.setupConnection(conn);
                 return conn;
             }
             return new Promise((resolve) => {
-                let timer = null;
-                const done = (connection) => {
-                    if (timer) {
-                        clearTimeout(timer);
-                        timer = null;
-                    }
-                    if (connection) {
-                        this.addConnection(connection);
-                    }
-                    resolve(connection);
-                };
-                timer = setTimeout(() => {
-                    if (this.isValidConnection(conn)) {
-                        this.addConnection(conn);
-                        done(conn);
-                    }
-                    else {
-                        this.removeConnection(conn.peer, conn.connectionId);
-                        done(undefined);
-                    }
+                const timer = setTimeout(() => {
+                    conn.off('open', onOpen);
+                    conn.off('error', onError);
+                    conn.off('close', onClose);
+                    resolve(this.isValidConnection(conn) ? this.setupConnection(conn) : undefined);
                 }, constant_1.CONNECTION_TIMEOUT);
-                this.bindConnectionData(conn);
-                conn.on('error', (err) => {
-                    // duplicate 场景：连接池可能已有对方建的连接，不应删除
+                const onOpen = () => {
+                    clearTimeout(timer);
+                    conn.off('error', onError);
+                    conn.off('close', onClose);
+                    resolve(this.setupConnection(conn));
+                };
+                const onError = () => {
+                    clearTimeout(timer);
+                    conn.off('open', onOpen);
+                    conn.off('close', onClose);
                     const pooled = this.connectPool.get(conn.peer);
-                    if (this.isValidConnection(pooled)) {
-                        done(pooled);
-                        return;
-                    }
-                    this.removeConnection(conn.peer, conn.connectionId);
-                    done(null);
-                });
-                conn.on('close', () => {
-                    console.log('close------------>', conn.label);
-                    this.removeConnection(conn.peer, conn.connectionId);
-                    done(null);
-                });
-                conn.on('open', () => {
-                    done(conn);
-                });
+                    resolve(this.isValidConnection(pooled) ? pooled : undefined);
+                };
+                const onClose = () => {
+                    clearTimeout(timer);
+                    conn.off('open', onOpen);
+                    conn.off('error', onError);
+                    resolve(undefined);
+                };
+                conn.once('open', onOpen);
+                conn.once('error', onError);
+                conn.once('close', onClose);
             });
         });
     }
-    /** 绑定 DataConnection 的 data 事件 */
+    setupConnection(conn) {
+        this.connectPool.set(conn.peer, conn);
+        this.bindConnectionData(conn);
+        conn.on('close', () => this.onConnClosed(conn));
+        conn.on('error', () => this.onConnClosed(conn));
+        return conn;
+    }
+    onConnClosed(conn) {
+        this.connectPool.delete(conn.peer);
+        const reqIds = this.connRequests.get(conn.connectionId);
+        if (reqIds) {
+            for (const reqId of reqIds) {
+                const cb = this.requests.get(reqId);
+                if (cb) {
+                    cb({ error: { message: 'connection closed', code: 'CONN_CLOSED' } });
+                    this.requests.delete(reqId);
+                }
+            }
+            this.connRequests.delete(conn.connectionId);
+        }
+    }
+    removeConnection(peerId, connectionId) {
+        var _a, _b, _c;
+        const conn = this.connectPool.get(peerId);
+        if (conn) {
+            if (connectionId && conn.connectionId !== connectionId)
+                return;
+            this.connectPool.delete(peerId);
+            this.connRequests.delete(conn.connectionId);
+            conn.removeAllListeners();
+            conn.close();
+            (_a = this.peer) === null || _a === void 0 ? void 0 : _a._removeConnection(conn);
+        }
+        else {
+            const connections = ((_b = this.peer) === null || _b === void 0 ? void 0 : _b.connections) || {};
+            for (const c of connections[peerId] || []) {
+                c.removeAllListeners();
+                c.close();
+                (_c = this.peer) === null || _c === void 0 ? void 0 : _c._removeConnection(c);
+            }
+        }
+    }
+    isValidConnection(conn) {
+        if (!(conn === null || conn === void 0 ? void 0 : conn.open))
+            return false;
+        if (!(conn === null || conn === void 0 ? void 0 : conn.peerConnection))
+            return false;
+        return ['connected', 'completed'].includes(conn.peerConnection.connectionState);
+    }
     bindConnectionData(conn) {
         conn.on('data', (message) => {
             switch (message.scope) {
@@ -554,39 +289,29 @@ class PeerTransfer {
             }
         });
     }
+    // ── Request / Reply ─────────────────────────────────────────────
     request(peerId, payload) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             const requestId = payload.requestId || (yield this.genRequestId());
-            const maxRetry = 2;
             let res;
-            for (let attempt = 0; attempt <= maxRetry; attempt++) {
+            for (let attempt = 0; attempt <= 2; attempt++) {
                 res = yield this.doRequestOnce(peerId, payload, requestId);
-                console.log('request once', res);
                 const code = (_a = res.error) === null || _a === void 0 ? void 0 : _a.code;
-                if (!res.error || (code !== 'CONN_CLOSED' && code !== 'CONN_FAILED')) {
+                if (!res.error || (code !== 'CONN_CLOSED' && code !== 'CONN_FAILED'))
                     return res;
-                }
             }
             return res;
         });
     }
-    /**
-     * 执行一次请求，返回带错误码的结果供外层判断是否重试
-     * @param peerId - 目标 peerId
-     * @param payload - 请求负载
-     * @param requestId - 请求ID（重试时复用）
-     * @returns error.code: CONN_CLOSED/CONN_FAILED（可重试）、TIMEOUT（不重试）
-     */
     doRequestOnce(peerId, payload, requestId) {
         return __awaiter(this, void 0, void 0, function* () {
-            console.log('doRequestOnce@@', peerId, this.destroyed, payload.route);
             if (this.destroyed) {
                 return Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'destroyed', code: 'CONN_CLOSED' } });
             }
             const conn = yield this.connectToPeer(peerId);
             if (!this.isValidConnection(conn)) {
-                return Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'build connection failed', code: 'CONN_FAILED' } });
+                return Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'connection failed', code: 'CONN_FAILED' } });
             }
             return new Promise((resolve) => {
                 let timeout = null;
@@ -595,39 +320,30 @@ class PeerTransfer {
                         clearTimeout(timeout);
                         timeout = null;
                     }
-                    this.inRequest.delete(requestId);
                     this.requests.delete(requestId);
-                    // 清理 addRequest 可能创建的定时器
-                    const oldTimer = this.requestTimers.get(requestId);
-                    if (oldTimer) {
-                        clearTimeout(oldTimer);
-                        this.requestTimers.delete(requestId);
+                    const reqs = this.connRequests.get(conn.connectionId);
+                    if (reqs) {
+                        reqs.delete(requestId);
+                        if (reqs.size === 0)
+                            this.connRequests.delete(conn.connectionId);
                     }
                 };
                 timeout = setTimeout(() => {
-                    // 先清理，避免 removeConnection 触发 feedback 二次 resolve
                     cleanup();
                     this.removeConnection(conn.peer, conn.connectionId);
-                    resolve(Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'request timeout', code: 'TIMEOUT' } }));
+                    resolve(Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'timeout', code: 'TIMEOUT' } }));
                 }, payload.timeout || entity_1.REQUEST_TIMEOUT);
-                this.inRequest.set(requestId, {
-                    conn,
-                    message: payload,
-                    feedback: () => {
-                        cleanup();
-                        resolve(Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'send failed', code: 'CONN_CLOSED' } }));
-                    },
-                });
-                // 直接 set，避免 addRequest 内部 setTimeout 在重试时误删新回调
+                let reqs = this.connRequests.get(conn.connectionId);
+                if (!reqs) {
+                    reqs = new Set();
+                    this.connRequests.set(conn.connectionId, reqs);
+                }
+                reqs.add(requestId);
                 this.requests.set(requestId, (message) => {
                     cleanup();
-                    const now = Date.now();
-                    if (now - message.createdAt > 3000) {
-                        console.warn('[egos] slow peer request:', message.route, now - message.createdAt);
-                    }
                     resolve(message);
                 });
-                this.send(conn, Object.assign(Object.assign({}, payload), { requestId, headers: Object.assign({}, payload.headers) })).catch(() => {
+                this.send(conn, Object.assign(Object.assign({}, payload), { requestId })).catch(() => {
                     cleanup();
                     resolve(Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'send failed', code: 'CONN_CLOSED' } }));
                 });
@@ -638,8 +354,8 @@ class PeerTransfer {
         return __awaiter(this, void 0, void 0, function* () {
             const data = Object.assign(Object.assign(Object.assign({}, this.inheritMessage(oldMessage)), message), { dest: conn.peer, scope: entity_1.PeerScope.RESPONSE, updatedAt: Date.now() });
             if (!this.isValidConnection(conn)) {
-                const connection = yield this.connectToPeer(conn.peer);
-                return connection === null || connection === void 0 ? void 0 : connection.send(data);
+                const c = yield this.connectToPeer(conn.peer);
+                return c === null || c === void 0 ? void 0 : c.send(data);
             }
             return conn.send(data);
         });
@@ -649,115 +365,96 @@ class PeerTransfer {
             const internalApi = yield this.getApi(conn.peer);
             let connection = conn;
             if (!this.isValidConnection(conn)) {
-                const con = yield this.connectToPeer(conn.peer);
-                if (!con) {
+                const c = yield this.connectToPeer(conn.peer);
+                if (!c)
                     return this.responseFail(conn, message, 'send with invalid connection');
-                }
-                connection = con;
+                connection = c;
             }
             const requestId = message.requestId || (yield this.genRequestId());
             return connection.send(Object.assign(Object.assign({}, message), { requestId, headers: Object.assign(Object.assign({}, message.headers), { ['x-device-token']: internalApi === null || internalApi === void 0 ? void 0 : internalApi.token }), scope: entity_1.PeerScope.REQUEST, action: entity_1.PeerAction.SEND, src: this.peerId, dest: conn.peer, createdAt: Date.now() }), false);
         });
     }
-    inheritMessage(receiveMsg) {
-        return {
-            src: this.peerId,
-            id: receiveMsg.id,
-            requestId: receiveMsg.requestId,
-            route: receiveMsg.route,
-            createdAt: receiveMsg.createdAt,
-            action: entity_1.PeerAction.RECEIVE,
-        };
-    }
-    reconnect() {
+    // ── Ping ────────────────────────────────────────────────────────
+    ping(peerId) {
         return __awaiter(this, void 0, void 0, function* () {
-            console.log('reconnect', this.isPaused);
-            if (this.isPaused) {
-                return;
+            if (this.deviceId === peerId)
+                return false;
+            const conn = this.connectPool.get(peerId);
+            if (!this.isValidConnection(conn)) {
+                this.removeConnection(peerId, conn === null || conn === void 0 ? void 0 : conn.connectionId);
+                return false;
             }
-            if (this.reconnectingPromise) {
-                return yield this.reconnectingPromise;
+            try {
+                const requestId = yield this.genRequestId();
+                return new Promise((resolve) => {
+                    const timer = setTimeout(() => { this.requests.delete(requestId); resolve(false); }, constant_1.PING_TIMEOUT);
+                    this.requests.set(requestId, () => { clearTimeout(timer); resolve(true); });
+                    conn.send({
+                        route: entity_1.PeerRoutes.HEARTBEAT, method: 'get', body: {}, requestId,
+                        scope: entity_1.PeerScope.REQUEST, action: entity_1.PeerAction.SEND,
+                        src: this.peerId, dest: peerId, headers: {}, createdAt: Date.now(),
+                    });
+                });
+            }
+            catch (_a) {
+                return false;
             }
-            this.reconnectingPromise = this.doReconnect();
-            return yield this.reconnectingPromise.finally(() => {
-                this.reconnectingPromise = undefined;
-            });
         });
     }
-    isValidConnection(conn) {
-        if (!(conn === null || conn === void 0 ? void 0 : conn.open)) {
-            return false;
-        }
-        if (!(conn === null || conn === void 0 ? void 0 : conn.peerConnection)) {
-            return false;
-        }
-        return ['connected', 'completed'].includes(conn.peerConnection.connectionState);
+    // ── Server helpers ──────────────────────────────────────────────
+    getApiHost() {
+        var _a, _b, _c;
+        const protocol = ((_a = this.peerConfig) === null || _a === void 0 ? void 0 : _a.secure) ? 'https' : 'http';
+        const host = ((_b = this.peerConfig) === null || _b === void 0 ? void 0 : _b.host) || 'localhost';
+        const port = ((_c = this.peerConfig) === null || _c === void 0 ? void 0 : _c.port) || 9000;
+        return `${protocol}://${host}:${port}`;
     }
-    doReconnect() {
+    getDeviceStatus(peerId) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
             try {
-                if (this.isPaused) {
-                    return;
-                }
-                // 已连接且 token 未变，无需重连
-                if (((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open) && this.peerConfig.token === ((_b = this.peer) === null || _b === void 0 ? void 0 : _b.options.token)) {
-                    return this.peer;
-                }
-                // 指数退避
+                const res = yield axios_1.default.get(`${this.getApiHost()}/api/v1/devices/${peerId}/status`);
+                if (res.status < 400)
+                    return res.data.data;
+            }
+            catch ( /* ignore */_a) { /* ignore */ }
+        });
+    }
+    // ── Reconnection ────────────────────────────────────────────────
+    reconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.destroyed || this._reconnecting)
+                return;
+            this._reconnecting = true;
+            try {
                 this.reconnectAttempt++;
                 const backoff = Math.min(BASE_RECONNECT_BACKOFF * Math.pow(2, this.reconnectAttempt - 1), MAX_RECONNECT_BACKOFF);
                 yield (0, delay_1.default)(backoff);
                 yield this.reloadConfig();
-                // 优先尝试 peer.reconnect() 轻量重连
-                if (((_c = this.peer) === null || _c === void 0 ? void 0 : _c.disconnected) && ((_d = this.peer) === null || _d === void 0 ? void 0 : _d.options.token) === this.peerConfig.token) {
-                    this.peer.reconnect();
-                    return this.peer;
-                }
-                return this.createPeer();
+                return yield this.createPeer();
             }
-            catch (err) {
+            catch (_a) {
                 return this.createPeer();
             }
+            finally {
+                this._reconnecting = false;
+            }
         });
     }
-    clearInstance() {
-        var _a, _b;
-        console.info('clearInstance');
-        this.destroyed = true;
-        PeerTransfer.connecting.clear();
-        // 先触发所有 inRequest 的 feedback，让它们 resolve
-        for (const [reqId, entry] of this.inRequest) {
-            entry.feedback();
-        }
-        this.inRequest.clear();
-        const peerIds = Array.from(this.connectPool.keys());
-        for (const pId of peerIds) {
-            this.removeConnection(pId);
-        }
-        this.requests.clear();
-        for (const timer of this.requestTimers.values()) {
-            clearTimeout(timer);
-        }
-        this.requestTimers.clear();
-        (_a = this.peer) === null || _a === void 0 ? void 0 : _a.destroy();
-        (_b = this.peer) === null || _b === void 0 ? void 0 : _b.removeAllListeners();
-        this.booted = undefined;
-        this.peer = undefined;
-        if (this.checkerId) {
-            clearInterval(this.checkerId);
-            this.checkerId = null;
-        }
-    }
-    destroy() {
-        this.clearInstance();
-        this.onDestroy();
+    // ── Message helpers ─────────────────────────────────────────────
+    inheritMessage(receiveMsg) {
+        return {
+            src: this.peerId,
+            id: receiveMsg.id,
+            requestId: receiveMsg.requestId,
+            route: receiveMsg.route,
+            createdAt: receiveMsg.createdAt,
+            action: entity_1.PeerAction.RECEIVE,
+        };
     }
+    // ── Router integration ──────────────────────────────────────────
     onRequest(conn, message) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
             try {
-                console.log('onRequest@@', (_a = conn.peer) === null || _a === void 0 ? void 0 : _a.substring(0, 4), message.route);
                 yield this.router.run(conn, message);
             }
             catch (err) {
@@ -765,7 +462,7 @@ class PeerTransfer {
             }
         });
     }
-    onResponse(conn, message) {
+    onResponse(_conn, message) {
         return __awaiter(this, void 0, void 0, function* () {
             const cb = this.requests.get(message.requestId);
             if (cb) {
@@ -784,37 +481,34 @@ class PeerTransfer {
             return this.reply(conn, message, { body: {}, error: err || 'service error' });
         });
     }
-    addRequest(id, cb) {
-        // 清除已有定时器，避免重复注册时旧定时器误删新回调
-        const oldTimer = this.requestTimers.get(id);
-        if (oldTimer) {
-            clearTimeout(oldTimer);
-        }
-        this.requests.set(id, cb);
-        const timer = setTimeout(() => {
-            this.requests.delete(id);
-            this.requestTimers.delete(id);
-        }, this.timeout);
-        this.requestTimers.set(id, timer);
-    }
     use(handler, prefix = '') {
         this.router.use(handler, prefix);
     }
     addRoute(route) {
         this.router.add(route);
     }
-    stop() {
-        this.isPaused = true;
-        this.destroy();
+    // ── Lifecycle ───────────────────────────────────────────────────
+    clearInstance() {
+        this.destroyed = true;
+        for (const peerId of Array.from(this.connectPool.keys())) {
+            this.removeConnection(peerId);
+        }
+        this.requests.clear();
+        this.connRequests.clear();
+        this.destroyPeer();
+    }
+    destroy() {
+        this.clearInstance();
+        this.onDestroy();
     }
-    resume() {
-        this.isPaused = false;
-        this.destroyed = false;
-        return this.createPeer(true);
+    destroyPeer() {
+        var _a, _b;
+        (_a = this.peer) === null || _a === void 0 ? void 0 : _a.destroy();
+        (_b = this.peer) === null || _b === void 0 ? void 0 : _b.removeAllListeners();
+        this.peer = undefined;
     }
 }
 exports.PeerTransfer = PeerTransfer;
-PeerTransfer.connecting = new Map();
 __exportStar(require("./interfaces"), exports);
 __exportStar(require("./handler"), exports);
 __exportStar(require("./file-transfer"), exports);