wechaty-puppet-matrix 0.0.8 → 0.0.10

package/src/matrix/service/request.ts

@@ -330,9 +330,21 @@ async function getAtWxidList (source: string): Promise<string[]> {
   }
   return []
 }
+interface ConnectionStatus {
+  status: 'disconnected' | 'connected' | 'connecting'
+}
 class Client extends EventEmitter {
 
   private readonly options: PuppetMatrixOptions
+  private connectionStatus: ConnectionStatus = { status: 'disconnected' }
+  private readonly MAX_RECONNECT_ATTEMPTS = 10
+  private readonly INITIAL_RECONNECT_DELAY = 1000 // 1秒
+  private readonly MAX_RECONNECT_DELAY = 30000 // 30秒
+  private readonly HEARTBEAT_INTERVAL = 40 * 1000 // 1分钟心跳间隔
+  private readonly HEARTBEAT_TIMEOUT = 5000 // 5秒超时
+  private reconnectAttempts = 0
+  private heartbeatTimer?: any
+  private heartbeatTimeoutTimer?: any
   socket: any
   server: any
   tokenInfo: any
@@ -386,102 +398,177 @@ class Client extends EventEmitter {
 
   async initServer () {
     await this.getTokenInfo()
-    if (!this.socket) {
-      const ws = new WebSocket(
-        `${this.tokenInfo.endpoint}?guid=${this.tokenInfo.guid}`,
-        { perMessageDeflate: true, maxPayload: 100 * 1024 * 1024 },
-      )
-
-      /**
-       * 1. Message
-       *  1.1. Deal with payload
-       */
-      ws.on('message', (data: string) => {
-        log.silly(PRE, 'initWebSocket() ws.on(message): %s', data)
-        try {
-          const payload: any = JSON.parse(data)
-          log.info(JSON.stringify(payload))
-          void this.eventParse(payload)
-        } catch (e: any) {
-          log.warn(PRE, 'initWebSocket() ws.on(message) exception: %s', e)
-          this.emit('error', e.message)
-        }
-      })
+    if (this.socket) {
+      log.error('socket had already been opened!')
+      return
+    }
+
+    await this.createWebSocket()
+  }
+
+  async createWebSocket (): Promise<void> {
+    if (!this.tokenInfo) {
+      log.error('Token info not available')
+      return
+    }
+    const ws = new WebSocket(
+      `${this.tokenInfo.endpoint}?guid=${this.tokenInfo.guid}`,
+      {
+        perMessageDeflate: true,
+        maxPayload: 100 * 1024 * 1024,
+      },
+    )
 
-      /**
-       * 1. Message
-       *  1.2. use websocket message as heartbeat source
-       */
-      ws.on('message', () => {
-        // if (!this.throttleQueue || !this.debounceQueue) {
-        //   log.warn(PRE, 'initWebSocket() ws.on(message) throttleQueue or debounceQueue not exist')
-        //   return
-        // }
-        // if (this.connectionStatus.status === CONNECTED) {
-        //   this.debounceQueue.next('ws.on(message)')
-        //   this.throttleQueue.next('ws.on(message)')
-        // }
+    // 连接建立前的 Promise
+    await new Promise<void>((resolve, reject) => {
+      ws.once('open', () => {
+        this.connectionStatus.status = 'connected'
+        this.reconnectAttempts = 0
+        log.info('WebSocket connection opened')
+        resolve()
       })
 
-      /**
-       * 2. Error
-       */
-      ws.on('error', (e: any) => {
-        if (e.message.indexOf('ECONNREFUSED') !== -1) {
-          // Can not connect to remote server, if this is triggered when puppet-padchat is connected,
-          // an close event must be emitted, so ignore this error
-          // If this is triggered when puppet-padchat is trying to reconnect, also ignore this error
-        } else {
-          log.verbose(PRE, 'initWebSocket() ws.on(error) %s', e)
-          this.emit('error', e)
-        }
+      ws.once('error', (error: any) => {
+        log.warn('WebSocket connection error', error)
+        reject(error)
       })
 
-      /**
-       * 3. Close
-       */
-      ws.on('close', (code: any, reason: any) => {
-        log.warn(
-          PRE,
-          'initWebSocket() ws.on(close) code: %s, reason: %s',
-          code,
-          reason,
-        )
-
-        // if (!this.reconnectThrottleQueue) {
-        //   log.warn(PRE, 'initWebSocket() ws.on(close) reconnectThrottleQueue not exist')
-        //   return
-        // }
-        // if (this.connectionStatus.status === CONNECTED) {
-        //   this.reconnectThrottleQueue.next('ws.on(close, ' + code + ')')
-        // }
+      ws.once('close', (code: any, reason: any) => {
+        void this.handleWebSocketClose(code, reason)
+        reject(new Error(`WebSocket closed: ${code} - ${reason}`))
       })
+    })
+    this.socket = ws
 
-      /**
-       * 5. Wait the WebSocket to be connected
-       */
-      await new Promise((resolve, reject) => {
-        ws.once('open', () => {
-          log.silly(PRE, 'initWebSocket() Promise() ws.on(open)')
-          return resolve({})
-        })
+    // 设置事件处理器
+    this.setupWebSocketListeners(ws)
+  }
 
-        ws.once('error', (e: any) => {
-          log.silly(PRE, 'initWebSocket() Promise() ws.on(error) %s', e)
-          return reject(e)
-        })
-        ws.once('close', (e: any) => {
-          log.silly(PRE, 'initWebSocket() Promise() ws.on(close)')
-          return reject(e)
-        })
-      })
+  private setupWebSocketListeners (ws: WebSocket): void {
+    // 消息处理
+    ws.on('message', (data: string) => {
+      this.resetHeartbeatTimeout() // 收到任何消息都重置心跳超时
+      log.silly(PRE, 'initWebSocket() ws.on(message): %s', data)
+      if (data.toString() === 'pong') {
+        log.info('Received heartbeat')
+        return
+      }
+      try {
+        const payload = JSON.parse(data)
+        log.info('Received payload', JSON.stringify(payload))
+        void this.eventParse(payload)
+      } catch (error) {
+        log.warn(PRE, 'initWebSocket() ws.on(message) exception: %s', error)
+        // @ts-ignore
+        this.emit('error', (error as Error).message)
+      }
+    })
 
-      this.socket = ws
-      return
+    // 错误处理
+    ws.on('error', (error: Error) => {
+      if ((error as any).code === 'ECONNREFUSED') {
+        log.verbose('Connection refused, potential reconnect scenario')
+        return
+      }
+
+      log.verbose(PRE, 'initWebSocket() ws.on(error) %s', error)
+      // @ts-ignore
+      this.emit('error', error)
+    })
+
+    // 关闭处理
+    ws.on('close', (code:any, reason: any) => {
+      this.stopHeartbeat()
+      void this.handleWebSocketClose(code, reason)
+    })
+    // 启动心跳
+    this.startHeartbeat()
+  }
+
+  private startHeartbeat (): void {
+    this.stopHeartbeat() // 确保清理现有定时器
+    this.socket?.send('ping')
+    this.heartbeatTimer = setInterval(() => {
+      if (this.socket?.readyState === WebSocket.OPEN) {
+        try {
+          this.socket.send('ping')
+          this.setHeartbeatTimeout()
+        } catch (error) {
+          log.error('Failed to send heartbeat:', error)
+          void this.handleWebSocketClose(1006, 'Heartbeat failed')
+        }
+      }
+    }, this.HEARTBEAT_INTERVAL)
+  }
+
+  private stopHeartbeat (): void {
+    if (this.heartbeatTimer) {
+      // @ts-ignore
+      clearInterval(this.heartbeatTimer)
+      this.heartbeatTimer = undefined
+    }
+    if (this.heartbeatTimeoutTimer) {
+      // @ts-ignore
+      clearTimeout(this.heartbeatTimeoutTimer)
+      this.heartbeatTimeoutTimer = undefined
+    }
+  }
+
+  private setHeartbeatTimeout (): void {
+    if (this.heartbeatTimeoutTimer) {
+      // @ts-ignore
+      clearTimeout(this.heartbeatTimeoutTimer)
+    }
+    this.heartbeatTimeoutTimer = setTimeout(() => {
+      log.warn('Heartbeat timeout, reconnecting...')
+      void this.handleWebSocketClose(1006, 'Heartbeat timeout')
+    }, this.HEARTBEAT_TIMEOUT)
+  }
+
+  private resetHeartbeatTimeout (): void {
+    if (this.heartbeatTimeoutTimer) {
+      // @ts-ignore
+      clearTimeout(this.heartbeatTimeoutTimer)
+      this.heartbeatTimeoutTimer = undefined
     }
+  }
+
+  private async handleWebSocketClose (code?: number, reason?: Buffer | String) {
+    this.connectionStatus.status = 'disconnected'
+    log.warn(`WebSocket closed: Code ${code}, Reason ${reason}`)
     if (this.socket) {
-      throw new Error('socket had already been opened!')
+      this.socket.close()
+      this.socket = null
+    }
+
+    // 触发重连
+    await this.reconnect()
+
+  }
+
+  private async reconnect (): Promise<void> {
+    if (this.reconnectAttempts >= this.MAX_RECONNECT_ATTEMPTS) {
+      log.error('Max reconnect attempts reached. Stopping reconnection.')
+      return
     }
+
+    // 指数退避重连策略
+    const delay = Math.min(
+      this.INITIAL_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts),
+      this.MAX_RECONNECT_DELAY,
+    )
+
+    this.reconnectAttempts++
+    log.info(`Reconnecting in ${delay}ms (Attempt ${this.reconnectAttempts})`)
+
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    setTimeout(async () => {
+      try {
+        await this.initServer()
+      } catch (error) {
+        log.warn('Reconnection failed', error)
+      }
+    }, delay)
   }
 
   async eventParse (eventData: any) {
@@ -734,6 +821,7 @@ class Client extends EventEmitter {
    * 获取登录二维码
    */
   public async getQrcode (): Promise<{
+    isLogin: boolean;
     base64: string;
     qrcodeUrl: string;
     expiredTime: number;
@@ -747,12 +835,23 @@ class Client extends EventEmitter {
 
       if (res?.qrcode) {
         return {
+          isLogin: false,
           base64: `data:image/jpeg;base64,${res?.qrcode?.buffer}`,
           qrcodeUrl: `http://weixin.qq.com/x/${res?.uuid}`,
           uuid: res?.uuid,
           expiredTime: res?.expiredTime,
         }
       }
+      if (res.errcode === -1 && res.errmsg === 'user is login status, please logout') {
+        log.info(PRE, 'getQrcode tips: %s', JSON.stringify(res))
+        return {
+          isLogin: true,
+          base64: '',
+          qrcodeUrl: '',
+          uuid: '',
+          expiredTime: 0,
+        }
+      }
       log.info(PRE, 'getQrcode error: %s', JSON.stringify(res))
       return null
     } catch (e) {
@@ -865,7 +964,7 @@ class Client extends EventEmitter {
           labelIdlist: contact?.labelIdlist,
         }
       }
-      log.info(PRE, 'get self info error:(%s)', res?.errmsg)
+      log.info(PRE, 'get self info error:(%s)', JSON.stringify(res))
       return false
     } catch (e) {
       log.error(PRE, 'getSelfInfo(): %s', e)

package/src/puppet-matrix.ts

@@ -224,6 +224,10 @@ class PuppetMatrix extends PUPPET.Puppet {
   private async _getQrcode () {
     const qrcode = await this._client?.getQrcode()
     if (qrcode) {
+      if (qrcode.isLogin) {
+        await this.checkIsLogin()
+        return
+      }
       if (this._qrcodeStatuasInterval) {
         clearInterval(this._qrcodeStatuasInterval)
         this._qrcodeStatuasInterval = null