@workclaw/openclaw-workclaw 1.0.17 → 1.0.19

package/src/gateway/reconnect.ts

@@ -1,149 +0,0 @@
-/**
- * Reconnect Scheduler - manages WebSocket reconnection with exponential backoff
- * Supports both per-account and per-appKey strategies
- */
-
-import type { WorkClawBaseConfig } from '../types.js'
-import { clearOpenclawWorkclawTokenCache } from '../connection/workclaw-client.js'
-import { clearOpenclawWorkclawWsConnection, setOpenclawWorkclawWsConnection } from '../runtime.js'
-
-export interface ReconnectSchedulerOptions {
-  /** Key for WebSocket storage: accountId (per-account) or appKey (per-appKey) */
-  key: string
-  config: WorkClawBaseConfig
-  log?: {
-    info?: (msg: string) => void
-    warn?: (msg: string) => void
-    error?: (msg: string) => void
-    debug?: (msg: string) => void
-  }
-  onMessage: (data: string) => void
-  onReconnectSuccess?: () => void
-}
-
-export function createReconnectScheduler(options: ReconnectSchedulerOptions): {
-  scheduleReconnect: () => void
-  stopReconnect: () => void
-} {
-  const { key, config, log, onMessage, onReconnectSuccess } = options
-
-  let reconnectBackoff = 5000
-  let shouldStopReconnect = false
-  let pendingReconnectTimer: NodeJS.Timeout | null = null
-
-  const scheduleReconnect = (): void => {
-    if (shouldStopReconnect) {
-      log?.info?.(`Reconnect: Stopped due to previous auth failure`)
-      return
-    }
-    if (pendingReconnectTimer !== null) {
-      log?.info?.(`Reconnect: Already scheduled, skipping duplicate`)
-      return
-    }
-
-    const jitter = Math.floor(Math.random() * 3000)
-    const delayMs = reconnectBackoff + jitter
-    log?.info?.(`Reconnect: Scheduling in ${delayMs}ms (base=${reconnectBackoff} + jitter=${jitter}) key=${key}`)
-
-    pendingReconnectTimer = setTimeout(async () => {
-      pendingReconnectTimer = null
-      try {
-        log?.info?.(`Reconnect: Attempting... key=${key}`)
-
-        const tokenCacheKey = config.appKey || key
-        clearOpenclawWorkclawTokenCache(tokenCacheKey)
-
-        const connConfig = {
-          baseUrl: config.baseUrl || '',
-          websocketUrl: config.websocketUrl,
-          appKey: config.appKey,
-          appSecret: config.appSecret,
-          localIp: config.localIp,
-          allowInsecureTls: config.allowInsecureTls,
-          requestTimeout: config.requestTimeout,
-        }
-
-        const { openOpenclawWorkclawConnection } = await import('../connection/workclaw-client.js')
-        const { endpoint, ticket } = await openOpenclawWorkclawConnection(tokenCacheKey, connConfig)
-        const url = `${endpoint}?ticket=${encodeURIComponent(ticket)}`
-
-        const { Agent } = await import('undici')
-        const dispatcher = connConfig.allowInsecureTls
-          ? new Agent({ connect: { rejectUnauthorized: false } })
-          : undefined
-        const wsOptions = dispatcher ? { dispatcher } : undefined
-
-        const ws = new (await import('undici')).WebSocket(url, wsOptions)
-        setOpenclawWorkclawWsConnection(key, ws)
-
-        ws.onopen = () => {
-          log?.info?.(`Reconnect: Success`)
-          reconnectBackoff = 5000
-          onReconnectSuccess?.()
-        }
-
-        ws.onmessage = (event: any) => {
-          const data = typeof event.data === 'string' ? event.data : String(event.data ?? '')
-          log?.info?.(`Reconnect: Message bytes=${data.length}`)
-          onMessage(data)
-        }
-
-        ws.onclose = (event: any) => {
-          const code = String(event?.code ?? '')
-          const reason = String(event?.reason ?? '')
-          log?.warn?.(`Reconnect: Closed code=${code} reason=${reason}`)
-          clearOpenclawWorkclawWsConnection(key)
-          scheduleReconnect()
-        }
-
-        ws.onerror = (event: any) => {
-          log?.error?.(`Reconnect: Error: ${String(event?.message ?? event)}`)
-        }
-      }
-      catch (err) {
-        const errorStr = String(err)
-        log?.error?.(`Reconnect: Failed: ${errorStr}`)
-
-        if (errorStr.includes('访问过于频繁')) {
-          log?.warn?.(`Reconnect: Rate limited, retrying with minimal backoff`)
-          if (pendingReconnectTimer !== null) {
-            clearTimeout(pendingReconnectTimer)
-            pendingReconnectTimer = null
-          }
-          reconnectBackoff = 1000
-          scheduleReconnect()
-          return
-        }
-
-        const isAuthError
-          = errorStr.includes('"errCode":2001')
-            || errorStr.includes('"code":2001')
-            || errorStr.includes('鉴权失败')
-            || errorStr.includes('invalid credentials')
-            || errorStr.includes('unauthorized')
-
-        if (isAuthError) {
-          log?.error?.(`Reconnect: Authentication failed, stopping`)
-          shouldStopReconnect = true
-          if (pendingReconnectTimer !== null) {
-            clearTimeout(pendingReconnectTimer)
-            pendingReconnectTimer = null
-          }
-          return
-        }
-
-        scheduleReconnect()
-      }
-    }, delayMs)
-  }
-
-  const stopReconnect = (): void => {
-    shouldStopReconnect = true
-    if (pendingReconnectTimer !== null) {
-      clearTimeout(pendingReconnectTimer)
-      pendingReconnectTimer = null
-    }
-  }
-
-  return { scheduleReconnect, stopReconnect }
-}