@workclaw/openclaw-workclaw 1.0.0

package/src/gateway/reconnect.ts

@@ -0,0 +1,149 @@
+/**
+ * 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 }
+}