egos-transfer 0.2.3 → 0.2.5

package/dist/index.js

@@ -33,22 +33,32 @@ 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
 class PeerTransfer {
-    constructor(deviceId, config, isRadomPeerId = false) {
-        this.retry = 0;
+    constructor(deviceId, config, isRandomPeerId = false) {
+        this.checkerId = null;
+        /** 重连尝试次数，成功连接后归零 */
+        this.reconnectAttempt = 0;
+        /** 标记实例已销毁，防止异步操作继续 */
+        this.destroyed = false;
+        /** 按 requestId 追踪进行中的请求 */
         this.inRequest = new Map();
         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 = isRadomPeerId ? deviceId + '_' + Date.now() : deviceId;
+        this.peerId = isRandomPeerId ? deviceId + '_' + Date.now() : deviceId;
         this.deviceId = deviceId;
     }
     createPeer() {
         return __awaiter(this, arguments, void 0, function* (force = false) {
             var _a;
+            console.log('createPeer', this.isPaused, force);
             if (this.isPaused && !force) {
                 return;
             }
@@ -65,81 +75,90 @@ class PeerTransfer {
             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* () {
-            try {
-                if (this.checkerId) {
-                    clearInterval(this.checkerId);
-                }
-                if (this.booted) {
-                    return this.booted;
-                }
-                this.booted = new Promise((resolve) => {
-                    const timer = setTimeout(() => {
-                        resolve(null);
-                    }, constant_1.PEER_OPEN_TIMEOUT);
-                    const done = (peer) => {
-                        clearTimeout(timer);
-                        resolve(peer);
-                    };
-                    peer.on('open', (id) => {
-                        console.log('peer@open', Date.now());
-                        clearTimeout(timer);
-                        done(peer);
-                    });
-                    peer.on('disconnected', () => {
-                        if (!this.isPaused) {
-                            setTimeout(() => {
-                                if (!this.isPaused) {
-                                    this.reconnect();
-                                }
-                            }, constant_1.CONNECTION_RETRY);
-                        }
-                    });
-                    // duplicated with close event
-                    peer.on('close', (...args) => { });
-                    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.type === 'network') {
-                            done(null);
-                            return this.reconnect();
-                        }
-                        if (err.type === 'server-error') {
-                            done(null);
-                            return this.reconnect();
-                        }
-                        done(null);
-                        return this.createPeer(true);
-                    }));
-                });
-                peer.on('connection', (conn) => {
-                    conn.label = 'incoming';
-                    this.onConnect(conn);
+            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);
                 });
-                const socket = peer.socket;
-                socket === null || socket === void 0 ? void 0 : socket.on('message', (message) => {
-                    this.handleSocketMessage(message);
+                // peer.on('disconnected', () => {
+                //   if (!this.isPaused) {
+                //     this.reconnect();
+                //   }
+                // });
+                peer.on('close', () => {
+                    setTimeout(() => {
+                        if (!this.isPaused && !this.destroyed) {
+                            this.reconnect();
+                        }
+                    }, constant_1.CONNECTION_TIMEOUT);
                 });
-                this.onHeartbeat({ type: 'HEARTBEAT' });
+                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);
+                }));
+            });
+            peer.on('connection', (conn) => {
+                conn.label = 'incoming';
+                this.onConnect(conn);
+            });
+            const socket = peer.socket;
+            socket === null || socket === void 0 ? void 0 : socket.on('message', (message) => {
+                this.handleSocketMessage(message);
+            });
+            this.onHeartbeat({ type: 'HEARTBEAT' });
+            try {
                 yield this.booted;
             }
-            catch (err) {
-                this.booted = undefined;
+            catch (_a) {
+                // booted rejected via timer timeout
             }
             finally {
                 this.booted = undefined;
@@ -157,10 +176,7 @@ class PeerTransfer {
         this.onHeartbeat(message);
     }
     onHeartbeat(message) {
-        if (message.type !== 'HEARTBEAT') {
-            return;
-        }
-        if (this.isPaused) {
+        if (message.type !== 'HEARTBEAT' || this.isPaused) {
             return;
         }
     }
@@ -179,7 +195,6 @@ class PeerTransfer {
                     message: 'peer conflict',
                 },
             });
-            return;
         }
     }
     onOpen(message) {
@@ -192,32 +207,24 @@ class PeerTransfer {
             if (message.type !== 'ONLINE') {
                 return;
             }
-            const deviceId = message.payload.deviceId;
-            this.online(deviceId);
+            this.online(message.payload.deviceId);
         });
     }
     onDeviceOffline(message) {
         if (message.type !== 'OFFLINE') {
             return;
         }
-        const deviceId = message.payload.deviceId;
-        this.ping(deviceId);
+        this.ping(message.payload.deviceId);
     }
     removeConnection(peerId, connectionId) {
         var _a, _b, _c;
-        // console.trace('removeConnection@', peerId, connectionId);
         const conn = this.connectPool.get(peerId);
         if (conn) {
             if (connectionId && conn.connectionId !== connectionId) {
                 return;
             }
-            const sending = this.inRequest.get(conn.connectionId);
-            if (sending) {
-                // 提前结束request，避免关闭连接时触发反馈
-                sending.feedback();
-                this.inRequest.delete(conn.connectionId);
-            }
             this.connectPool.delete(peerId);
+            this.handleConnectionClose(peerId, conn);
             conn.removeAllListeners();
             conn.close();
             (_a = this.peer) === null || _a === void 0 ? void 0 : _a._removeConnection(conn);
@@ -226,16 +233,52 @@ class PeerTransfer {
             const connections = ((_b = this.peer) === null || _b === void 0 ? void 0 : _b.connections) || {};
             const conns = connections[peerId] || [];
             if (conns.length > 0) {
-                for (const conn of conns) {
-                    conn.removeAllListeners();
-                    conn.close();
-                    (_c = this.peer) === null || _c === void 0 ? void 0 : _c._removeConnection(conn);
+                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 }));
+                }
+            }
+        });
+    }
     addConnection(conn) {
-        // console.log('addConnection@', conn.label);
         this.connectPool.set(conn.peer, conn);
         const connecting = PeerTransfer.connecting.get(conn.peer);
         if (connecting) {
@@ -253,21 +296,24 @@ class PeerTransfer {
             }
             // turn credential expires
             if (this.peerConfig.turnExpiredAt && this.peerConfig.turnExpiredAt - 30000 < Date.now()) {
-                // this.connectPool.clear();
                 yield this.reloadConfig();
                 yield this.createPeer(true);
                 return;
             }
-            const deviceIds = this.connectPool.keys();
-            for (const deviceId of deviceIds) {
+            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);
+                    return;
                 }
-                else {
-                    this.ping(conn.peer);
+                const ok = yield this.ping(conn.peer);
+                if (!ok) {
+                    this.removeConnection(conn.peer, conn.connectionId);
                 }
-            }
+            }));
+            // 并行执行，不阻塞下个心跳周期
+            yield Promise.allSettled(pingTasks);
         }), constant_1.HEARTBEAT_INTERVAL);
     }
     getApiHost() {
@@ -283,8 +329,7 @@ class PeerTransfer {
                 const apiHost = this.getApiHost();
                 const res = yield axios_1.default.get(`${apiHost}/api/v1/devices/${peerId}/status`);
                 if (res.status < 400) {
-                    const data = res.data;
-                    return data.data;
+                    return res.data.data;
                 }
             }
             catch (err) {
@@ -292,12 +337,11 @@ class PeerTransfer {
             }
         });
     }
-    connectToPeer(deviceId) {
+    connectToPeer(peerId) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (deviceId === this.deviceId) {
+            if (peerId === this.deviceId) {
                 return;
             }
-            const peerId = deviceId;
             const existingConn = this.connectPool.get(peerId);
             console.log('connectToPeer', this.isPaused, this.connectPool.size);
             if (existingConn) {
@@ -320,17 +364,22 @@ class PeerTransfer {
     }
     createConnection(peerId) {
         return __awaiter(this, void 0, void 0, function* () {
-            let resolve;
-            let reject;
             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 {
@@ -341,8 +390,10 @@ class PeerTransfer {
                         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, {
@@ -354,9 +405,17 @@ class PeerTransfer {
                         }
                         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);
+                        }
                     }
+                    clearTimeout(guardTimer);
                     resolve(undefined);
                     return undefined;
                 }
@@ -372,6 +431,9 @@ class PeerTransfer {
             return conn;
         });
     }
+    /**
+     * 心跳检测 - 直接 send，不走 request 管线，避免重试放大
+     */
     ping(peerId) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.deviceId === peerId) {
@@ -379,20 +441,37 @@ class PeerTransfer {
             }
             const conn = this.connectPool.get(peerId);
             if (!this.isValidConnection(conn)) {
-                this.removeConnection(conn === null || conn === void 0 ? void 0 : conn.peer, conn === null || conn === void 0 ? void 0 : conn.connectionId);
+                this.removeConnection(peerId, conn === null || conn === void 0 ? void 0 : conn.connectionId);
                 return;
             }
-            const res = yield this.request(conn.peer, {
-                route: entity_1.PeerRoutes.HEARTBEAT,
-                method: 'get',
-                body: {},
-                timeout: constant_1.PING_TIMEOUT,
-            });
-            if (!res || res.error) {
-                this.removeConnection(conn.peer, conn.connectionId);
+            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;
             }
-            return true;
         });
     }
     onConnect(conn) {
@@ -401,9 +480,9 @@ class PeerTransfer {
                 return;
             }
             const exists = this.connectPool.get(conn.peer);
-            // console.log('onConnect', conn.label, exists);
             if (exists) {
-                if (exists.metadata.time > conn.metadata.time) {
+                // 双方同时建连时，保留 peerId 字典序大的那条（确定性，不依赖时间戳）
+                if (exists.connectionId > conn.connectionId) {
                     this.removeConnection(conn.peer, conn.connectionId);
                     if (this.isValidConnection(exists)) {
                         return exists;
@@ -413,19 +492,24 @@ class PeerTransfer {
                     this.removeConnection(exists.peer, exists.connectionId);
                 }
             }
-            let timer = null;
+            if (conn.open) {
+                this.addConnection(conn);
+                this.bindConnectionData(conn);
+                return conn;
+            }
             return new Promise((resolve) => {
+                let timer = null;
                 const done = (connection) => {
-                    if (connection) {
-                        this.addConnection(connection);
-                    }
                     if (timer) {
                         clearTimeout(timer);
                         timer = null;
                     }
+                    if (connection) {
+                        this.addConnection(connection);
+                    }
                     resolve(connection);
                 };
-                timer = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                timer = setTimeout(() => {
                     if (this.isValidConnection(conn)) {
                         this.addConnection(conn);
                         done(conn);
@@ -434,85 +518,120 @@ class PeerTransfer {
                         this.removeConnection(conn.peer, conn.connectionId);
                         done(undefined);
                     }
-                    timer = null;
-                }), constant_1.CONNECTION_TIMEOUT);
-                conn.on('data', (message) => {
-                    switch (message.scope) {
-                        case entity_1.PeerScope.REQUEST:
-                            return this.onRequest(conn, message);
-                        case entity_1.PeerScope.RESPONSE:
-                            return this.onResponse(conn, message);
-                        default:
-                            return this.responseFail(conn, message, 'unknown scope');
+                }, constant_1.CONNECTION_TIMEOUT);
+                this.bindConnectionData(conn);
+                conn.on('error', (err) => {
+                    // duplicate 场景：连接池可能已有对方建的连接，不应删除
+                    const pooled = this.connectPool.get(conn.peer);
+                    if (this.isValidConnection(pooled)) {
+                        done(pooled);
+                        return;
                     }
-                });
-                conn.on('error', (err) => __awaiter(this, void 0, void 0, function* () {
                     this.removeConnection(conn.peer, conn.connectionId);
-                    // if (!this.peer?.open) {
-                    //   await this.reconnect();
-                    // }
                     done(null);
-                }));
-                conn.on('close', () => __awaiter(this, void 0, void 0, function* () {
+                });
+                conn.on('close', () => {
                     console.log('close------------>', conn.label);
-                    clearTimeout(timer);
                     this.removeConnection(conn.peer, conn.connectionId);
-                    // if (!this.peer?.open) {
-                    //   await this.reconnect();
-                    // }
                     done(null);
-                }));
-                conn.on('open', () => __awaiter(this, void 0, void 0, function* () {
-                    clearTimeout(timer);
-                    done(conn);
-                }));
-                if (this.isValidConnection(conn)) {
-                    if (timer) {
-                        clearTimeout(timer);
-                    }
-                    timer = null;
+                });
+                conn.on('open', () => {
                     done(conn);
-                }
+                });
             });
         });
     }
+    /** 绑定 DataConnection 的 data 事件 */
+    bindConnectionData(conn) {
+        conn.on('data', (message) => {
+            switch (message.scope) {
+                case entity_1.PeerScope.REQUEST:
+                    return this.onRequest(conn, message);
+                case entity_1.PeerScope.RESPONSE:
+                    return this.onResponse(conn, message);
+                default:
+                    return this.responseFail(conn, message, 'unknown scope');
+            }
+        });
+    }
     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++) {
+                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')) {
+                    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: -1 } });
+                return Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'build connection failed', code: 'CONN_FAILED' } });
             }
-            const requestId = payload.requestId || (yield this.genRequestId());
-            const q = new Promise((resolve) => {
-                const timeout = setTimeout(() => {
-                    const msg = {
-                        body: {},
-                        error: { message: 'request timeout' },
-                    };
+            return new Promise((resolve) => {
+                let timeout = null;
+                const cleanup = () => {
+                    if (timeout) {
+                        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);
+                    }
+                };
+                timeout = setTimeout(() => {
+                    // 先清理，避免 removeConnection 触发 feedback 二次 resolve
+                    cleanup();
                     this.removeConnection(conn.peer, conn.connectionId);
-                    resolve(msg);
+                    resolve(Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'request timeout', code: 'TIMEOUT' } }));
                 }, payload.timeout || entity_1.REQUEST_TIMEOUT);
-                this.inRequest.set(conn.connectionId, {
+                this.inRequest.set(requestId, {
                     conn,
                     message: payload,
-                    feedback: () => resolve({
-                        body: {},
-                        error: { message: 'send failed' },
-                    }),
+                    feedback: () => {
+                        cleanup();
+                        resolve(Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'send failed', code: 'CONN_CLOSED' } }));
+                    },
                 });
-                this.addRequest(requestId, (message) => {
-                    clearTimeout(timeout);
+                // 直接 set，避免 addRequest 内部 setTimeout 在重试时误删新回调
+                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);
                     }
-                    this.inRequest.delete(conn.connectionId);
                     resolve(message);
                 });
+                this.send(conn, Object.assign(Object.assign({}, payload), { requestId, headers: Object.assign({}, payload.headers) })).catch(() => {
+                    cleanup();
+                    resolve(Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'send failed', code: 'CONN_CLOSED' } }));
+                });
             });
-            yield this.send(conn, Object.assign(Object.assign({}, payload), { requestId, headers: Object.assign({}, payload.headers) }));
-            const res = yield q;
-            return res;
         });
     }
     reply(conn, oldMessage, message) {
@@ -529,7 +648,7 @@ class PeerTransfer {
         return __awaiter(this, void 0, void 0, function* () {
             const internalApi = yield this.getApi(conn.peer);
             let connection = conn;
-            if (!this.isValidConnection) {
+            if (!this.isValidConnection(conn)) {
                 const con = yield this.connectToPeer(conn.peer);
                 if (!con) {
                     return this.responseFail(conn, message, 'send with invalid connection');
@@ -537,8 +656,7 @@ class PeerTransfer {
                 connection = con;
             }
             const requestId = message.requestId || (yield this.genRequestId());
-            const sent = yield 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);
-            return sent;
+            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) {
@@ -553,6 +671,7 @@ class PeerTransfer {
     }
     reconnect() {
         return __awaiter(this, void 0, void 0, function* () {
+            console.log('reconnect', this.isPaused);
             if (this.isPaused) {
                 return;
             }
@@ -581,20 +700,21 @@ class PeerTransfer {
                 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;
                 }
+                // 指数退避
+                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();
-                return this.createPeer();
-                // return this.createPeer();
+                // 优先尝试 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;
                 }
-                else {
-                    yield this.reloadConfig();
-                    return this.createPeer();
-                }
+                return this.createPeer();
             }
             catch (err) {
                 return this.createPeer();
@@ -603,11 +723,23 @@ class PeerTransfer {
     }
     clearInstance() {
         var _a, _b;
+        console.info('clearInstance');
+        this.destroyed = true;
         PeerTransfer.connecting.clear();
-        const peerIds = this.connectPool.keys();
+        // 先触发所有 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;
@@ -623,10 +755,9 @@ class PeerTransfer {
     }
     onRequest(conn, message) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             try {
-                // @todo default folder
-                // console.log('onRequest-->', message.route);
-                // @todo default folder
+                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) {
@@ -636,37 +767,35 @@ class PeerTransfer {
     }
     onResponse(conn, message) {
         return __awaiter(this, void 0, void 0, function* () {
-            // @todo default folder
             const cb = this.requests.get(message.requestId);
             if (cb) {
                 cb.apply(this, [message]);
                 this.requests.delete(message.requestId);
             }
-            // @todo throw err;
         });
     }
     responseOk(conn, message) {
         return __awaiter(this, void 0, void 0, function* () {
-            const msg = {
-                body: { ok: true },
-            };
-            return this.reply(conn, message, msg);
+            return this.reply(conn, message, { body: { ok: true } });
         });
     }
     responseFail(conn, message, err) {
         return __awaiter(this, void 0, void 0, function* () {
-            const msg = {
-                body: {},
-                error: err || 'service error',
-            };
-            return this.reply(conn, message, msg);
+            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);
-        setTimeout(() => {
+        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);
@@ -680,6 +809,7 @@ class PeerTransfer {
     }
     resume() {
         this.isPaused = false;
+        this.destroyed = false;
         return this.createPeer(true);
     }
 }