egos-transfer 0.2.2 → 0.2.4

package/src/index.ts

@@ -1,16 +1,15 @@
 import {
+  CONNECTION_DUPLICATED,
   CONNECTION_LIMIT_EXCEED,
   CONNECTION_PEER_CONFLICT,
-  CONNECTION_RETRY,
   CONNECTION_TIMEOUT,
   HEARTBEAT_INTERVAL,
   PEER_OPEN_TIMEOUT,
   PING_TIMEOUT,
   UNAUTHORIZED,
 } from './constant';
-import { DataConnection, MediaConnection, Peer, PeerOptions } from 'peerjs';
+import { DataConnection, Peer, PeerOptions } from 'peerjs';
 import {
-  DataMessage,
   IDeviceStatus,
   IMessage,
   PeerMessage,
@@ -34,6 +33,10 @@ type PeerTransferOptions = PeerOptions & {
   turnExpiredAt: number; // date time ms
 };
 
+/** 重连退避相关常量 */
+const MAX_RECONNECT_BACKOFF = 30000; // 最大退避 30s
+const BASE_RECONNECT_BACKOFF = 1000; // 基础退避 1s
+
 export abstract class PeerTransfer {
   protected peer: Peer | undefined;
   protected connectPool: Map<string, DataConnection>;
@@ -46,34 +49,41 @@ export abstract class PeerTransfer {
     }
   > = new Map();
 
-  protected retry = 0;
-
   protected peerConfig: PeerTransferOptions | undefined;
-  public deviceId: string;
+  public readonly deviceId: string;
+  /** 接入 peerjs 服务端的 peerId，默认与 deviceId 相同 */
+  public readonly peerId: string;
   protected requests: Map<string, ResponseCb>;
+  /** 追踪 addRequest 的延时清理定时器，避免重试时误删新回调 */
+  protected requestTimers: Map<string, ReturnType<typeof setTimeout>>;
   protected timeout: number;
   protected router: PeerRouter;
-  protected booted: Promise<Peer | undefined>;
+  protected booted: Promise<Peer | undefined> | undefined;
   protected reconnectingPromise: Promise<Peer | undefined> | undefined;
-  protected checkerId!: ReturnType<typeof setInterval>;
+  protected checkerId: ReturnType<typeof setInterval> | null = null;
   public isPaused: boolean;
-  public peerId: string;
+  /** 重连尝试次数，成功连接后归零 */
+  protected reconnectAttempt = 0;
+  /** 标记实例已销毁，防止异步操作继续 */
+  protected destroyed = false;
+  /** 按 requestId 追踪进行中的请求 */
   private inRequest: Map<
     string,
     { conn: DataConnection; message: Record<string, any>; feedback: () => void }
   > = new Map();
 
-  constructor(deviceId: string, config: PeerTransferOptions, isRadomPeerId = false) {
+  constructor(deviceId: string, config: PeerTransferOptions, isRandomPeerId = false) {
     this.connectPool = new Map<string, DataConnection>();
     this.peerConfig = {
       ...config,
       key: String(Date.now()),
     };
     this.requests = new Map();
+    this.requestTimers = new Map();
     this.timeout = REQUEST_TIMEOUT;
     this.router = new PeerRouter();
     this.isPaused = false;
-    this.peerId = isRadomPeerId ? deviceId + '_' + Date.now() : deviceId;
+    this.peerId = isRandomPeerId ? deviceId + '_' + Date.now() : deviceId;
     this.deviceId = deviceId;
   }
 
@@ -81,7 +91,7 @@ export abstract class PeerTransfer {
   abstract online(deviceId: string): void;
   abstract offline(deviceId: string): void;
   abstract genRequestId(): Promise<string>;
-  abstract getApi(deviceId: string): Promise<InternalApi | undefined>;
+  abstract getApi(peerId: string): Promise<InternalApi | undefined>;
   abstract discoverDeviceById(deviceId: string): Promise<void>;
   abstract onDestroy(): void;
   abstract requireAuth(): Promise<void>;
@@ -89,6 +99,7 @@ export abstract class PeerTransfer {
   abstract reloadConfig(config?: Record<string, any>): Promise<void>;
 
   async createPeer(force = false): Promise<Peer | undefined> {
+    console.log('createPeer', this.isPaused, force);
     if (this.isPaused && !force) {
       return;
     }
@@ -108,80 +119,89 @@ export abstract class PeerTransfer {
     this.peer = peer;
     await this.initialize(this.peer);
     this.checkConnection();
+    this.destroyed = false;
     return this.peer;
   }
+
   async initialize(peer: Peer) {
-    try {
-      if (this.checkerId) {
-        clearInterval(this.checkerId);
-      }
+    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);
-        }, PEER_OPEN_TIMEOUT);
-        const done = (peer?: 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();
-              }
-            }, CONNECTION_RETRY);
-          }
-        });
-        // duplicated with close event
-        peer.on('close', (...args) => {});
-        peer.on('error', async (err) => {
-          if (err.message === CONNECTION_PEER_CONFLICT) {
-            this.stop();
-            done(null);
-            return;
-          }
-          if (err.message === CONNECTION_LIMIT_EXCEED) {
-            this.stop();
-            this.onConnectLimit();
-            return done(null);
-          }
-          if (err.message == 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);
-        });
+    if (this.booted) {
+      return this.booted;
+    }
+    this.booted = new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        resolve(null);
+      }, PEER_OPEN_TIMEOUT);
+      const done = (p?: Peer) => {
+        clearTimeout(timer);
+        resolve(p);
+      };
+      peer.on('open', (id) => {
+        console.log('peer@open');
+        this.reconnectAttempt = 0; // 连接成功，重置退避计数
+        done(peer);
       });
-      peer.on('connection', (conn: DataConnection) => {
-        conn.label = 'incoming';
-        this.onConnect(conn);
+      // peer.on('disconnected', () => {
+      //   if (!this.isPaused) {
+      //     this.reconnect();
+      //   }
+      // });
+      peer.on('close', () => {
+        setTimeout(() => {
+          if (!this.isPaused && !this.destroyed) {
+            this.reconnect();
+          }
+        }, CONNECTION_TIMEOUT);
       });
-      const socket = peer.socket;
-      socket?.on('message', (message: IMessage) => {
-        this.handleSocketMessage(message);
+      peer.on('error', async (err) => {
+        if (err.message === CONNECTION_PEER_CONFLICT) {
+          this.stop();
+          done(null);
+          return;
+        }
+        if (err.message === CONNECTION_LIMIT_EXCEED) {
+          this.onConnectLimit();
+          return done(null);
+        }
+        if (err.message === UNAUTHORIZED) {
+          done(null);
+          return this.requireAuth();
+        }
+        if (err.message === 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);
       });
-      this.onHeartbeat({ type: 'HEARTBEAT' } as IMessage);
+    });
+    peer.on('connection', (conn: DataConnection) => {
+      conn.label = 'incoming';
+      this.onConnect(conn);
+    });
+    const socket = peer.socket;
+    socket?.on('message', (message: IMessage) => {
+      this.handleSocketMessage(message);
+    });
+    this.onHeartbeat({ type: 'HEARTBEAT' } as IMessage);
+    try {
       await this.booted;
-    } catch (err) {
-      this.booted = undefined;
+    } catch {
+      // booted rejected via timer timeout
     } finally {
       this.booted = undefined;
     }
@@ -199,10 +219,7 @@ export abstract class PeerTransfer {
   }
 
   onHeartbeat(message: IMessage) {
-    if (message.type !== 'HEARTBEAT') {
-      return;
-    }
-    if (this.isPaused) {
+    if (message.type !== 'HEARTBEAT' || this.isPaused) {
       return;
     }
   }
@@ -221,7 +238,6 @@ export abstract class PeerTransfer {
           message: 'peer conflict',
         },
       });
-      return;
     }
   }
 
@@ -235,33 +251,25 @@ export abstract class PeerTransfer {
     if (message.type !== 'ONLINE') {
       return;
     }
-    const deviceId = message.payload.deviceId;
-    this.online(deviceId);
+    this.online(message.payload.deviceId);
   }
 
   onDeviceOffline(message: IMessage) {
     if (message.type !== 'OFFLINE') {
       return;
     }
-    const deviceId = message.payload.deviceId;
-    this.ping(deviceId);
+    this.ping(message.payload.deviceId);
   }
 
   removeConnection(peerId: string, connectionId?: string) {
-    // 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();
       this.peer?._removeConnection(conn);
@@ -269,17 +277,61 @@ export abstract class PeerTransfer {
       const connections = this.peer?.connections || {};
       const conns = connections[peerId] || [];
       if (conns.length > 0) {
-        for (const conn of conns) {
-          conn.removeAllListeners();
-          conn.close();
-          this.peer?._removeConnection(conn);
+        for (const c of conns) {
+          c.removeAllListeners();
+          c.close();
+          this.peer?._removeConnection(c);
         }
       }
     }
   }
 
+  /**
+   * 连接关闭时尝试快速重连（5s 超时）：
+   * - 重连成功 → 保留 inRequest 条目，更新 conn 引用
+   * - 重连失败 → 触发 feedback 并清理 inRequest
+   */
+  private async handleConnectionClose(peerId: string, conn: DataConnection) {
+    const matchedEntries: Array<
+      [string, { conn: DataConnection; message: Record<string, any>; feedback: () => void }]
+    > = [];
+    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 = await Promise.race([
+      this.connectToPeer(peerId),
+      delay(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, {
+          ...entry,
+          conn: newConn,
+        });
+      }
+    }
+  }
+
   addConnection(conn: DataConnection) {
-    // console.log('addConnection@', conn.label);
     this.connectPool.set(conn.peer, conn);
     const connecting = PeerTransfer.connecting.get(conn.peer);
     if (connecting) {
@@ -297,20 +349,25 @@ export abstract class PeerTransfer {
       }
       // turn credential expires
       if (this.peerConfig.turnExpiredAt && this.peerConfig.turnExpiredAt - 30000 < Date.now()) {
-        // this.connectPool.clear();
         await this.reloadConfig();
         await 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(async (deviceId) => {
         const conn = this.connectPool.get(deviceId);
         if (!this.isValidConnection(conn)) {
           this.removeConnection(conn.peer, conn.connectionId);
-        } else {
-          this.ping(conn.peer);
+          return;
         }
-      }
+        const ok = await this.ping(conn.peer);
+        if (!ok) {
+          this.removeConnection(conn.peer, conn.connectionId);
+        }
+      });
+      // 并行执行，不阻塞下个心跳周期
+      await Promise.allSettled(pingTasks);
     }, HEARTBEAT_INTERVAL);
   }
 
@@ -320,25 +377,24 @@ export abstract class PeerTransfer {
     const port = this.peerConfig?.port || 9000;
     return `${protocol}://${host}:${port}`;
   }
+
   async getDeviceStatus(peerId: string): Promise<IDeviceStatus | undefined> {
     try {
       const apiHost = this.getApiHost();
       const res = await axios.get(`${apiHost}/api/v1/devices/${peerId}/status`);
       if (res.status < 400) {
-        const data = res.data;
-        return data.data as IDeviceStatus;
+        return (res.data as { data: IDeviceStatus }).data;
       }
     } catch (err) {
       console.log('getDeviceStatus@error', err);
     }
   }
 
-  async connectToPeer(deviceId: string): Promise<DataConnection | undefined> {
-    if (deviceId === this.deviceId) {
+  async connectToPeer(peerId: string): Promise<DataConnection | undefined> {
+    if (peerId === this.deviceId) {
       return;
     }
 
-    const peerId = deviceId;
     const existingConn = this.connectPool.get(peerId);
     console.log('connectToPeer', this.isPaused, this.connectPool.size);
     if (existingConn) {
@@ -361,18 +417,26 @@ export abstract class PeerTransfer {
   }
 
   private async createConnection(peerId: string): Promise<DataConnection | undefined> {
-    let resolve!: (value: DataConnection | undefined) => void;
-    let reject!: (reason?: any) => void;
     const q = PeerTransfer.connecting.get(peerId);
     if (q) {
       return q.promise;
     }
+
+    let resolve!: (value: DataConnection | undefined) => void;
+    let reject!: (reason?: any) => void;
     const connectionPromise = new Promise<DataConnection | undefined>((res, rej) => {
       resolve = res;
       reject = rej;
     });
 
     PeerTransfer.connecting.set(peerId, { promise: connectionPromise, resolve, reject });
+
+    // 兜底超时，防止 connecting 条目永远不清理
+    const guardTimer = setTimeout(() => {
+      PeerTransfer.connecting.delete(peerId);
+      resolve(undefined);
+    }, CONNECTION_TIMEOUT * 3);
+
     const doConnect = async () => {
       try {
         for (let retry = 0; retry < 3; retry++) {
@@ -385,6 +449,7 @@ export abstract class PeerTransfer {
 
           const cur = this.connectPool.get(peerId);
           if (this.isValidConnection(cur)) {
+            clearTimeout(guardTimer);
             return resolve(cur);
           }
 
@@ -397,9 +462,11 @@ export abstract class PeerTransfer {
           }
           const connection = await this.onConnect(conn as DataConnection).catch(() => {});
           if (connection) {
+            clearTimeout(guardTimer);
             return resolve(connection);
           }
         }
+        clearTimeout(guardTimer);
         resolve(undefined);
         return undefined;
       } catch (err) {
@@ -413,26 +480,47 @@ export abstract class PeerTransfer {
     return conn;
   }
 
+  /**
+   * 心跳检测 - 直接 send，不走 request 管线，避免重试放大
+   */
   async ping(peerId: string) {
     if (this.deviceId === peerId) {
       return;
     }
     const conn = this.connectPool.get(peerId);
     if (!this.isValidConnection(conn)) {
-      this.removeConnection(conn?.peer, conn?.connectionId);
+      this.removeConnection(peerId, conn?.connectionId);
       return;
     }
-    const res = await this.request(conn.peer, {
-      route: PeerRoutes.HEARTBEAT,
-      method: 'get',
-      body: {},
-      timeout: PING_TIMEOUT,
-    });
-    if (!res || res.error) {
-      this.removeConnection(conn.peer, conn.connectionId);
+    try {
+      const requestId = await this.genRequestId();
+      return new Promise<boolean>((resolve) => {
+        const timer = setTimeout(() => {
+          this.requests.delete(requestId);
+          resolve(false);
+        }, PING_TIMEOUT);
+
+        this.requests.set(requestId, () => {
+          clearTimeout(timer);
+          resolve(true);
+        });
+
+        conn.send({
+          route: PeerRoutes.HEARTBEAT,
+          method: 'get',
+          body: {},
+          requestId,
+          scope: PeerScope.REQUEST,
+          action: PeerAction.SEND,
+          src: this.peerId,
+          dest: peerId,
+          headers: {},
+          createdAt: Date.now(),
+        });
+      });
+    } catch {
       return false;
     }
-    return true;
   }
 
   async onConnect(conn: DataConnection): Promise<DataConnection | undefined> {
@@ -440,9 +528,9 @@ export abstract 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;
@@ -451,19 +539,28 @@ export abstract 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: ReturnType<typeof setTimeout> | null = null;
+
       const done = (connection?: DataConnection) => {
-        if (connection) {
-          this.addConnection(connection);
-        }
         if (timer) {
           clearTimeout(timer);
           timer = null;
         }
+        if (connection) {
+          this.addConnection(connection);
+        }
         resolve(connection);
       };
-      timer = setTimeout(async () => {
+
+      timer = setTimeout(() => {
         if (this.isValidConnection(conn)) {
           this.addConnection(conn);
           done(conn);
@@ -471,94 +568,139 @@ export abstract class PeerTransfer {
           this.removeConnection(conn.peer, conn.connectionId);
           done(undefined);
         }
-        timer = null;
       }, CONNECTION_TIMEOUT);
-      conn.on('data', (message: any) => {
-        switch (message.scope) {
-          case PeerScope.REQUEST:
-            return this.onRequest(conn, message);
-          case PeerScope.RESPONSE:
-            return this.onResponse(conn, message);
-          default:
-            return this.responseFail(conn, message, 'unknown scope');
-        }
-      });
-      conn.on('error', async (err) => {
+
+      this.bindConnectionData(conn);
+
+      conn.on('error', () => {
         this.removeConnection(conn.peer, conn.connectionId);
-        // if (!this.peer?.open) {
-        //   await this.reconnect();
-        // }
         done(null);
       });
-      conn.on('close', async () => {
+      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', async () => {
-        clearTimeout(timer);
+      conn.on('open', () => {
         done(conn);
       });
-      if (this.isValidConnection(conn)) {
-        if (timer) {
-          clearTimeout(timer);
-        }
-        timer = null;
-        done(conn);
+    });
+  }
+
+  /** 绑定 DataConnection 的 data 事件 */
+  private bindConnectionData(conn: DataConnection) {
+    conn.on('data', (message: any) => {
+      switch (message.scope) {
+        case PeerScope.REQUEST:
+          return this.onRequest(conn, message);
+        case PeerScope.RESPONSE:
+          return this.onResponse(conn, message);
+        default:
+          return this.responseFail(conn, message, 'unknown scope');
       }
     });
   }
 
   async request(peerId: string, payload: PeerRequestPayload): Promise<PeerMessage> {
+    const requestId = payload.requestId || (await this.genRequestId());
+    const maxRetry = 2;
+    let res: PeerMessage;
+    for (let attempt = 0; attempt <= maxRetry; attempt++) {
+      res = await this.doRequestOnce(peerId, payload, requestId);
+      console.log('request once', res);
+      const code = (res.error as Record<string, any>)?.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（不重试）
+   */
+  private async doRequestOnce(
+    peerId: string,
+    payload: PeerRequestPayload,
+    requestId: string,
+  ): Promise<PeerMessage> {
+    console.log('doRequestOnce@@', peerId, this.destroyed, payload.route);
+    if (this.destroyed) {
+      return { ...payload, body: {}, error: { message: 'destroyed', code: 'CONN_CLOSED' } } as any;
+    }
     const conn = await this.connectToPeer(peerId);
     if (!this.isValidConnection(conn)) {
       return {
         ...payload,
         body: {},
-        error: { message: 'build connection failed', code: -1 },
+        error: { message: 'build connection failed', code: 'CONN_FAILED' },
       } as any;
     }
 
-    const requestId = payload.requestId || (await this.genRequestId());
-    const q = new Promise<Record<string, any>>((resolve) => {
-      const timeout = setTimeout(() => {
-        const msg = {
-          body: {},
-          error: { message: 'request timeout' },
-        };
+    return new Promise((resolve) => {
+      let timeout: ReturnType<typeof setTimeout> | null = 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({
+          ...payload,
+          body: {},
+          error: { message: 'request timeout', code: 'TIMEOUT' },
+        } as any);
       }, payload.timeout || REQUEST_TIMEOUT);
-      this.inRequest.set(conn.connectionId, {
+
+      this.inRequest.set(requestId, {
         conn,
         message: payload,
-        feedback: () =>
+        feedback: () => {
+          cleanup();
           resolve({
+            ...payload,
             body: {},
-            error: { message: 'send failed' },
-          }),
+            error: { message: 'send failed', code: 'CONN_CLOSED' },
+          } as any);
+        },
       });
-      this.addRequest(requestId, (message: Record<string, any>) => {
-        clearTimeout(timeout);
+
+      // 直接 set，避免 addRequest 内部 setTimeout 在重试时误删新回调
+      this.requests.set(requestId, (message: Record<string, any>) => {
+        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);
+        resolve(message as any);
+      });
+
+      this.send(conn, { ...payload, requestId, headers: { ...payload.headers } }).catch(() => {
+        cleanup();
+        resolve({
+          ...payload,
+          body: {},
+          error: { message: 'send failed', code: 'CONN_CLOSED' },
+        } as any);
       });
     });
-    await this.send(conn, {
-      ...payload,
-      requestId,
-      headers: { ...payload.headers },
-    });
-    const res = await q;
-    return res as any;
   }
 
   async reply(
@@ -581,14 +723,13 @@ export abstract class PeerTransfer {
       const connection = await this.connectToPeer(conn.peer);
       return connection?.send(data);
     }
-
     return conn.send(data);
   }
 
   async send(conn: DataConnection, message: PeerRequestPayload) {
     const internalApi = await this.getApi(conn.peer);
     let connection = conn;
-    if (!this.isValidConnection) {
+    if (!this.isValidConnection(conn)) {
       const con = await this.connectToPeer(conn.peer);
       if (!con) {
         return this.responseFail(conn, message as PeerMessage, 'send with invalid connection');
@@ -596,7 +737,7 @@ export abstract class PeerTransfer {
       connection = con;
     }
     const requestId = message.requestId || (await this.genRequestId());
-    const sent = await connection.send(
+    return connection.send(
       {
         ...message,
         requestId,
@@ -612,7 +753,6 @@ export abstract class PeerTransfer {
       },
       false,
     );
-    return sent;
   }
 
   inheritMessage(receiveMsg: PeerMessage) {
@@ -627,6 +767,7 @@ export abstract class PeerTransfer {
   }
 
   async reconnect(): Promise<Peer | undefined> {
+    console.log('reconnect', this.isPaused);
     if (this.isPaused) {
       return;
     }
@@ -655,31 +796,55 @@ export abstract class PeerTransfer {
       if (this.isPaused) {
         return;
       }
+      // 已连接且 token 未变，无需重连
       if (this.peer?.open && this.peerConfig.token === this.peer?.options.token) {
         return this.peer;
       }
 
+      // 指数退避
+      this.reconnectAttempt++;
+      const backoff = Math.min(
+        BASE_RECONNECT_BACKOFF * Math.pow(2, this.reconnectAttempt - 1),
+        MAX_RECONNECT_BACKOFF,
+      );
+      await delay(backoff);
+
       await this.reloadConfig();
-      return this.createPeer();
-      // return this.createPeer();
+
+      // 优先尝试 peer.reconnect() 轻量重连
       if (this.peer?.disconnected && this.peer?.options.token === this.peerConfig.token) {
         this.peer.reconnect();
         return this.peer;
-      } else {
-        await this.reloadConfig();
-        return this.createPeer();
       }
+
+      return this.createPeer();
     } catch (err) {
       return this.createPeer();
     }
   }
 
   clearInstance() {
+    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();
+
     this.peer?.destroy();
     this.peer?.removeAllListeners();
     this.booted = undefined;
@@ -697,9 +862,7 @@ export abstract class PeerTransfer {
 
   async onRequest(conn: DataConnection, message: PeerMessage) {
     try {
-      // @todo default folder
-      // console.log('onRequest-->', message.route);
-      // @todo default folder
+      console.log('onRequest@@', conn.peer, message.route);
       await this.router.run(conn, message);
     } catch (err: any) {
       this.responseFail(conn, message, { message: err.message, code: err.code });
@@ -707,20 +870,15 @@ export abstract class PeerTransfer {
   }
 
   async onResponse(conn: DataConnection, message: PeerMessage) {
-    // @todo default folder
     const cb = this.requests.get(message.requestId);
     if (cb) {
       cb.apply(this, [message]);
       this.requests.delete(message.requestId);
     }
-    // @todo throw err;
   }
 
   async responseOk(conn: DataConnection, message: PeerMessage) {
-    const msg = {
-      body: { ok: true },
-    };
-    return this.reply(conn, message, msg);
+    return this.reply(conn, message, { body: { ok: true } });
   }
 
   async responseFail(
@@ -728,18 +886,21 @@ export abstract class PeerTransfer {
     message: PeerMessage,
     err: string | Record<string, any>,
   ) {
-    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: string, cb: ResponseCb) {
+    // 清除已有定时器，避免重复注册时旧定时器误删新回调
+    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: RequestCallbackFn, prefix = '') {
@@ -757,6 +918,7 @@ export abstract class PeerTransfer {
 
   resume() {
     this.isPaused = false;
+    this.destroyed = false;
     return this.createPeer(true);
   }
 }