@wu529778790/open-im 1.11.8-beta.8 → 1.11.8-beta.9

package/dist/clawbot/client.js

@@ -9,7 +9,8 @@
  */
 import { randomBytes } from 'node:crypto';
 import { createLogger } from '../logger.js';
-import { jitteredDelay, isFatalReconnectError, SLOW_PROBE_MS } from '../shared/reconnect.js';
+import { isFatalReconnectError } from '../shared/reconnect.js';
+import { ReconnectManager, HeartbeatMonitor, StateManager } from '../shared/connection-manager.js';
 import { cacheContextToken } from './message-sender.js';
 import { setClawbotContextToken, clearClawbotContextToken } from '../shared/active-chats.js';
 import { createMediaTargetPath } from '../shared/media-storage.js';
@@ -19,27 +20,30 @@ const log = createLogger('ClawBot');
 const RECONNECT_DELAYS_MS = [3000, 5000, 10000, 20000, 30000];
 const BASE_INFO = { channel_version: '0.1.0' };
 let pollController = null;
-let channelState = 'disconnected';
 let messageHandler = null;
-let stateChangeHandler = null;
-let reconnectTimer = null;
-let watchdogTimer = null;
-let reconnectAttempt = 0;
-let fatal = false;
 let stopped = false;
 let apiUrl = 'https://ilinkai.weixin.qq.com';
 let apiToken = '';
 /** Opaque cursor for getupdates pagination (replaces numeric offset) */
 let getUpdatesBuf = '';
-/** Timestamp of last successful poll response (for watchdog) */
-let lastResponseAt = 0;
 /** Per-request timeout for long-polling (ms) */
 const POLL_REQUEST_TIMEOUT_MS = 3 * 60 * 1000; // 3 minutes
 /** Watchdog interval: force reconnect if no response for this long (ms) */
 const WATCHDOG_INTERVAL_MS = 60_000; // check every 60s
 const WATCHDOG_STALE_MS = 5 * 60 * 1000; // 5 minutes without response = stale
+// Connection infrastructure (shared managers replace raw timers/counters)
+const stateManager = new StateManager('disconnected');
+const heartbeatMonitor = new HeartbeatMonitor();
+const reconnectManager = new ReconnectManager({
+    name: 'ClawBot',
+    backoff: { mode: 'stepped', delays: RECONNECT_DELAYS_MS },
+    onReconnect: () => {
+        stateManager.set('connected');
+        startPolling();
+    },
+});
 export function getChannelState() {
-    return channelState;
+    return stateManager.current;
 }
 export async function initClawbot(config, eventHandler, onStateChange) {
     const pc = config.platforms?.clawbot;
@@ -52,14 +56,14 @@ export async function initClawbot(config, eventHandler, onStateChange) {
     apiUrl = pc.apiUrl ?? 'https://ilinkai.weixin.qq.com';
     apiToken = pc.apiToken;
     messageHandler = eventHandler;
-    stateChangeHandler = onStateChange ?? null;
+    stateManager.setOnChange(onStateChange);
     stopped = false;
-    reconnectAttempt = 0;
-    fatal = false;
+    reconnectManager.reset();
+    reconnectManager.resume();
     getUpdatesBuf = '';
     // Start polling directly — no blocking connectivity check.
     // The polling loop handles errors and reconnection internally.
-    updateState('connected');
+    stateManager.set('connected');
     startPolling();
     log.info('ClawBot client initialized');
 }
@@ -82,18 +86,18 @@ function startPolling() {
                     base_info: BASE_INFO,
                 }, combinedSignal);
                 // Record successful response time for watchdog
-                lastResponseAt = Date.now();
+                heartbeatMonitor.recordResponse();
                 if (signal.aborted)
                     break;
                 if (!res.ok) {
                     // Detect fatal errors (e.g. errcode -14 "session timeout") — retrying won't help
                     if (res.errcode === -14 || isFatalReconnectError(res.error)) {
                         log.warn(`ClawBot fatal error (errcode=${res.errcode}), entering slow-probe mode`);
-                        fatal = true;
+                        reconnectManager.setFatal(true);
                         getUpdatesBuf = ''; // session expired, cursor is stale
                         clearClawbotContextToken(); // session expired, token is stale
-                        updateState('error');
-                        scheduleReconnect();
+                        stateManager.set('error');
+                        reconnectManager.schedule();
                         return;
                     }
                     log.warn(`ClawBot getupdates error: ${res.error ?? 'unknown'}`);
@@ -101,10 +105,9 @@ function startPolling() {
                     continue;
                 }
                 // Successful response — clear fatal mode and reset backoff
-                if (fatal || reconnectAttempt > 0) {
+                if (reconnectManager.fatal || reconnectManager.attemptCount > 0) {
                     log.info('ClawBot connection recovered');
-                    fatal = false;
-                    reconnectAttempt = 0;
+                    reconnectManager.reset();
                 }
                 // Update cursor for next poll
                 if (res.updatesBuf) {
@@ -189,69 +192,35 @@ function startPolling() {
                 if (err instanceof Error && err.name === 'AbortError')
                     break;
                 log.error('ClawBot polling error:', err);
-                updateState('error');
-                scheduleReconnect();
+                stateManager.set('error');
+                reconnectManager.schedule();
                 return;
             }
         }
     })();
 }
-function scheduleReconnect() {
-    if (stopped)
-        return;
-    if (reconnectTimer) {
-        clearTimeout(reconnectTimer);
-        reconnectTimer = null;
-    }
-    const baseDelay = RECONNECT_DELAYS_MS[Math.min(reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)];
-    const delay = fatal ? jitteredDelay(SLOW_PROBE_MS) : jitteredDelay(baseDelay);
-    reconnectAttempt++;
-    if (fatal) {
-        log.warn(`ClawBot fatal error, slow-probe in ${Math.round(delay / 1000)}s (attempt ${reconnectAttempt})...`);
-    }
-    else {
-        log.info(`ClawBot reconnecting in ${delay}ms (attempt ${reconnectAttempt})...`);
-    }
-    reconnectTimer = setTimeout(() => {
-        reconnectTimer = null;
-        if (stopped)
-            return;
-        updateState('connected');
-        startPolling();
-    }, delay);
-}
-function updateState(state) {
-    channelState = state;
-    stateChangeHandler?.(state);
-    log.debug(`ClawBot state: ${state}`);
-}
 /**
  * Watchdog: periodically check if the poll loop is alive.
  * After Mac sleep or network drop, the fetch may hang without throwing.
  * If no successful response for WATCHDOG_STALE_MS, force a reconnect.
  */
 function startWatchdog() {
-    stopWatchdog();
-    lastResponseAt = Date.now();
-    watchdogTimer = setInterval(() => {
-        if (stopped)
-            return;
-        const elapsed = Date.now() - lastResponseAt;
-        if (elapsed > WATCHDOG_STALE_MS) {
-            log.warn(`ClawBot watchdog: no response for ${Math.round(elapsed / 1000)}s, forcing reconnect`);
-            if (pollController) {
-                pollController.abort();
-                pollController = null;
-            }
-            updateState('error');
-            scheduleReconnect();
-        }
-    }, WATCHDOG_INTERVAL_MS);
+    heartbeatMonitor.recordResponse();
+    heartbeatMonitor.start(WATCHDOG_INTERVAL_MS, watchdogTick);
 }
-function stopWatchdog() {
-    if (watchdogTimer) {
-        clearInterval(watchdogTimer);
-        watchdogTimer = null;
+function watchdogTick() {
+    if (stopped)
+        return;
+    if (heartbeatMonitor.isStale(WATCHDOG_STALE_MS)) {
+        const elapsed = Date.now() - heartbeatMonitor.lastResponseTime;
+        log.warn(`ClawBot watchdog: no response for ${Math.round(elapsed / 1000)}s, forcing reconnect`);
+        heartbeatMonitor.stop();
+        if (pollController) {
+            pollController.abort();
+            pollController = null;
+        }
+        stateManager.set('error');
+        reconnectManager.schedule();
     }
 }
 /**
@@ -441,13 +410,10 @@ export function stopClawbot() {
         pollController.abort();
         pollController = null;
     }
-    if (reconnectTimer) {
-        clearTimeout(reconnectTimer);
-        reconnectTimer = null;
-    }
-    stopWatchdog();
+    reconnectManager.stop();
+    heartbeatMonitor.stop();
     messageHandler = null;
     // Don't clear context_token here — it's persisted for startup notifications
-    updateState('disconnected');
+    stateManager.set('disconnected');
     log.info('ClawBot client stopped');
 }

package/dist/qq/client.js

@@ -1,6 +1,6 @@
 import WebSocket from "ws";
 import { createLogger } from "../logger.js";
-import { jitteredDelay, SLOW_PROBE_MS } from "../shared/reconnect.js";
+import { ReconnectManager, HeartbeatMonitor } from "../shared/connection-manager.js";
 const log = createLogger("QQ");
 const TOKEN_URL = "https://bots.qq.com/app/getAppAccessToken";
 const API_BASE = "https://api.sgroup.qq.com";
@@ -12,25 +12,23 @@ const INTENTS = {
 };
 let client = null;
 let ws = null;
-let heartbeatTimer = null;
-let reconnectTimer = null;
 let stopped = false;
 let seq = null;
 let sessionId = null;
-let reconnectAttempt = 0;
 let connecting = false; // 防止并发 connectWebSocket
 let currentConfig = null;
 let currentHandler = null;
 let tokenState = null;
-let lastServerResponseTime = 0;
-function clearTimers() {
-    if (heartbeatTimer) {
-        clearInterval(heartbeatTimer);
-        heartbeatTimer = null;
-    }
-    if (reconnectTimer) {
-        clearTimeout(reconnectTimer);
-        reconnectTimer = null;
+// Connection infrastructure (shared managers replace raw timers/counters)
+const heartbeatMonitor = new HeartbeatMonitor();
+const reconnectManager = new ReconnectManager({
+    name: 'QQ',
+    backoff: { mode: 'stepped', delays: RECONNECT_DELAYS_MS },
+    onReconnect: () => reconnectFn(),
+});
+async function reconnectFn() {
+    if (currentConfig && currentHandler) {
+        await connectWebSocket(currentConfig, currentHandler);
     }
 }
 function buildAuthHeaders(token) {
@@ -143,28 +141,28 @@ function normalizeInboundEvent(payload) {
     }
     return null;
 }
-function startHeartbeat(intervalMs) {
-    lastServerResponseTime = Date.now();
-    if (heartbeatTimer)
-        clearInterval(heartbeatTimer);
-    heartbeatTimer = setInterval(() => {
-        if (!ws || ws.readyState !== WebSocket.OPEN)
-            return;
-        const elapsed = Date.now() - lastServerResponseTime;
-        if (lastServerResponseTime > 0 && elapsed > intervalMs * 3) {
-            log.warn(`QQ dead connection: no response for ${Math.round(elapsed / 1000)}s, reconnecting`);
-            clearTimers();
-            ws?.terminate();
-            connectWebSocket(currentConfig, currentHandler);
-            return;
-        }
-        try {
-            ws.send(JSON.stringify({ op: 1, d: seq }));
-        }
-        catch (err) {
-            log.warn('QQ heartbeat send failed:', err);
-        }
-    }, intervalMs);
+/**
+ * Heartbeat tick: send ping and detect stale connections.
+ * The heartbeat interval is dynamic (from QQ gateway HELLO message).
+ */
+let heartbeatIntervalMs = 30000;
+function heartbeatTick() {
+    if (!ws || ws.readyState !== WebSocket.OPEN)
+        return;
+    if (heartbeatMonitor.isStale(heartbeatIntervalMs * 3)) {
+        const elapsed = Date.now() - heartbeatMonitor.lastResponseTime;
+        log.warn(`QQ dead connection: no response for ${Math.round(elapsed / 1000)}s, reconnecting`);
+        heartbeatMonitor.stop();
+        ws?.terminate();
+        reconnectFn().catch((err) => log.error('QQ reconnect from heartbeat failed:', err));
+        return;
+    }
+    try {
+        ws.send(JSON.stringify({ op: 1, d: seq }));
+    }
+    catch (err) {
+        log.warn('QQ heartbeat send failed:', err);
+    }
 }
 async function connectWebSocket(config, handler) {
     // 防止并发连接
@@ -196,17 +194,17 @@ async function connectWebSocket(config, handler) {
             };
             socket.on("open", () => {
                 log.info("QQ gateway connected");
-                reconnectAttempt = 0;
+                reconnectManager.reset();
             });
             socket.on("message", async (raw) => {
-                lastServerResponseTime = Date.now();
+                heartbeatMonitor.recordResponse();
                 try {
                     const payload = JSON.parse(raw.toString());
                     if (typeof payload.s === "number")
                         seq = payload.s;
                     if (payload.op === 10) {
-                        const heartbeatInterval = Number(payload.d?.heartbeat_interval ?? 30000);
-                        startHeartbeat(heartbeatInterval);
+                        heartbeatIntervalMs = Number(payload.d?.heartbeat_interval ?? 30000);
+                        heartbeatMonitor.start(heartbeatIntervalMs, heartbeatTick);
                         socket.send(JSON.stringify({
                             op: sessionId ? 6 : 2,
                             d: sessionId
@@ -253,7 +251,7 @@ async function connectWebSocket(config, handler) {
             });
             socket.on("close", (code, reason) => {
                 settle(() => { }); // 清理 ready timeout
-                clearTimers();
+                heartbeatMonitor.stop();
                 ws = null;
                 const reasonStr = reason.toString();
                 if (code === 4009) {
@@ -273,19 +271,11 @@ async function connectWebSocket(config, handler) {
                     seq = null;
                 }
                 const isFatalClose = code === 4004 || code === 4006 || code === 4007;
-                const baseDelay = RECONNECT_DELAYS_MS[Math.min(reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)];
-                const delay = isFatalClose ? jitteredDelay(SLOW_PROBE_MS) : jitteredDelay(baseDelay);
                 if (isFatalClose) {
-                    log.warn(`QQ 致命关闭码 ${code}（鉴权失败），转慢探测（每 ${Math.round(SLOW_PROBE_MS / 1000)}s 一次）`);
+                    reconnectManager.setFatal(true);
+                    log.warn(`QQ 致命关闭码 ${code}（鉴权失败），转慢探测（每 ${Math.round(5 * 60)}s 一次）`);
                 }
-                reconnectAttempt += 1;
-                reconnectTimer = setTimeout(() => {
-                    if (currentConfig && currentHandler) {
-                        connectWebSocket(currentConfig, currentHandler).catch((err) => {
-                            log.error("QQ reconnect failed:", err);
-                        });
-                    }
-                }, delay);
+                reconnectManager.schedule();
             });
         });
     }
@@ -306,6 +296,8 @@ export async function initQQ(config, eventHandler) {
     stopped = false;
     currentConfig = config;
     currentHandler = eventHandler;
+    reconnectManager.reset();
+    reconnectManager.resume();
     client = {
         sendPrivateMessage: async (openid, content, replyToMessageId) => {
             const res = await apiRequest(config, "POST", `/v2/users/${openid}/messages`, buildMessageBody(content, replyToMessageId));
@@ -328,7 +320,8 @@ export async function initQQ(config, eventHandler) {
 }
 export async function stopQQ() {
     stopped = true;
-    clearTimers();
+    heartbeatMonitor.stop();
+    reconnectManager.stop();
     if (ws) {
         ws.close(1000);
         ws = null;
@@ -339,5 +332,4 @@ export async function stopQQ() {
     tokenState = null;
     sessionId = null;
     seq = null;
-    lastServerResponseTime = 0;
 }

package/dist/shared/connection-manager.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Shared connection management infrastructure for self-managing platform clients.
+ *
+ * Encapsulates three cross-cutting concerns duplicated across wework, clawbot,
+ * qq, and workbuddy clients:
+ *
+ * - **ReconnectManager**: jittered backoff scheduling with fatal→slow-probe mode
+ * - **HeartbeatMonitor**: interval-based heartbeat / watchdog timer
+ * - **StateManager**: state variable with change-notification callback
+ */
+export interface ReconnectManagerConfig {
+    /** Platform name used in log messages. */
+    name: string;
+    /**
+     * Delay strategy:
+     * - `{ mode: 'exponential', baseMs, maxMs, cap }` — exponential backoff
+     *   `min(baseMs * 1.5^floor(attempt / cap), maxMs)`.
+     * - `{ mode: 'stepped', delays }` — stepped array; last entry repeats.
+     */
+    backoff: {
+        mode: 'exponential';
+        baseMs: number;
+        maxMs: number;
+        cap?: number;
+    } | {
+        mode: 'stepped';
+        delays: number[];
+    };
+    /**
+     * After this many attempts the counter resets and retries continue
+     * (avoids permanent disconnection). 0 = unlimited (no reset).
+     */
+    maxAttempts?: number;
+    /** Callback invoked after the computed delay. */
+    onReconnect: () => void | Promise<void>;
+}
+/**
+ * Manages reconnection scheduling with jittered backoff and fatal→slow-probe.
+ *
+ * Replaces the duplicated `scheduleReconnect()` pattern across 4 client files:
+ * timer cleanup, attempt counting, backoff computation, jitter, logging.
+ */
+export declare class ReconnectManager {
+    private timer;
+    private attempt;
+    private _fatal;
+    private _stopped;
+    private readonly log;
+    private readonly cfg;
+    constructor(cfg: ReconnectManagerConfig);
+    get attemptCount(): number;
+    get fatal(): boolean;
+    get stopped(): boolean;
+    /** Mark a fatal (auth) error — next scheduleReconnect uses slow-probe delay. */
+    setFatal(value: boolean): void;
+    /** Reset attempt counter and fatal flag after a successful connection. */
+    reset(): void;
+    /**
+     * Schedule a reconnect attempt.  Clears any pending timer, computes the
+     * backoff delay (with jitter), and invokes `onReconnect` after the delay.
+     */
+    schedule(): void;
+    /** Cancel any pending reconnect timer. */
+    stop(): void;
+    /** Allow scheduling again (undo `stop`). */
+    resume(): void;
+    private clearTimer;
+    private computeBaseDelay;
+}
+/**
+ * Manages a setInterval-based heartbeat or watchdog timer.
+ *
+ * Replaces duplicated `heartbeatTimer` / `watchdogTimer` patterns:
+ * timer cleanup on re-start, clearInterval on stop.
+ */
+export declare class HeartbeatMonitor {
+    private timer;
+    private _lastResponseTime;
+    get lastResponseTime(): number;
+    /** Record that a response was received (for watchdog stale detection). */
+    recordResponse(): void;
+    /**
+     * Start a periodic callback.  Clears any existing timer first.
+     * @param intervalMs  Interval in milliseconds.
+     * @param onTick      Callback invoked on each tick.
+     */
+    start(intervalMs: number, onTick: () => void | Promise<void>): void;
+    /** Clear the heartbeat timer. */
+    stop(): void;
+    /**
+     * Watchdog convenience: returns true if more than `staleMs` have elapsed
+     * since the last `recordResponse()` call.
+     */
+    isStale(staleMs: number): boolean;
+}
+/**
+ * Manages a connection state variable with change-notification callback.
+ *
+ * Replaces duplicated `connectionState` / `channelState` + `stateChangeHandler`
+ * patterns across wework, clawbot, and workbuddy clients.
+ */
+export declare class StateManager<T extends string> {
+    private _state;
+    private onChange?;
+    constructor(initialState: T);
+    get current(): T;
+    /** Register a callback invoked whenever the state changes. */
+    setOnChange(handler: ((state: T) => void) | undefined): void;
+    /** Transition to a new state and notify the callback if it changed. */
+    set(newState: T): void;
+}

package/dist/shared/connection-manager.js

@@ -0,0 +1,157 @@
+/**
+ * Shared connection management infrastructure for self-managing platform clients.
+ *
+ * Encapsulates three cross-cutting concerns duplicated across wework, clawbot,
+ * qq, and workbuddy clients:
+ *
+ * - **ReconnectManager**: jittered backoff scheduling with fatal→slow-probe mode
+ * - **HeartbeatMonitor**: interval-based heartbeat / watchdog timer
+ * - **StateManager**: state variable with change-notification callback
+ */
+import { createLogger } from '../logger.js';
+import { jitteredDelay, SLOW_PROBE_MS } from './reconnect.js';
+/**
+ * Manages reconnection scheduling with jittered backoff and fatal→slow-probe.
+ *
+ * Replaces the duplicated `scheduleReconnect()` pattern across 4 client files:
+ * timer cleanup, attempt counting, backoff computation, jitter, logging.
+ */
+export class ReconnectManager {
+    timer = null;
+    attempt = 0;
+    _fatal = false;
+    _stopped = false;
+    log;
+    cfg;
+    constructor(cfg) {
+        this.cfg = cfg;
+        this.log = createLogger(`${cfg.name}/Reconnect`);
+    }
+    get attemptCount() { return this.attempt; }
+    get fatal() { return this._fatal; }
+    get stopped() { return this._stopped; }
+    /** Mark a fatal (auth) error — next scheduleReconnect uses slow-probe delay. */
+    setFatal(value) { this._fatal = value; }
+    /** Reset attempt counter and fatal flag after a successful connection. */
+    reset() {
+        this.attempt = 0;
+        this._fatal = false;
+    }
+    /**
+     * Schedule a reconnect attempt.  Clears any pending timer, computes the
+     * backoff delay (with jitter), and invokes `onReconnect` after the delay.
+     */
+    schedule() {
+        this.clearTimer();
+        if (this._stopped)
+            return;
+        const max = this.cfg.maxAttempts;
+        if (max && max > 0 && this.attempt >= max) {
+            this.log.warn(`Max reconnect attempts (${max}) reached, resetting counter`);
+            this.attempt = 0;
+        }
+        const baseDelay = this.computeBaseDelay();
+        const delay = this._fatal ? jitteredDelay(SLOW_PROBE_MS) : jitteredDelay(baseDelay);
+        this.attempt++;
+        const fatalTag = this._fatal ? ' [slow-probe]' : '';
+        this.log.info(`Reconnecting in ${delay}ms (attempt ${this.attempt})${fatalTag}...`);
+        this.timer = setTimeout(async () => {
+            this.timer = null;
+            try {
+                await this.cfg.onReconnect();
+            }
+            catch (err) {
+                this.log.warn(`Reconnect callback failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }, delay);
+    }
+    /** Cancel any pending reconnect timer. */
+    stop() {
+        this._stopped = true;
+        this.clearTimer();
+    }
+    /** Allow scheduling again (undo `stop`). */
+    resume() {
+        this._stopped = false;
+    }
+    clearTimer() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+    computeBaseDelay() {
+        const { backoff } = this.cfg;
+        if (backoff.mode === 'exponential') {
+            const cap = backoff.cap ?? 5;
+            return Math.min(backoff.baseMs * Math.pow(1.5, Math.floor(this.attempt / cap)), backoff.maxMs);
+        }
+        const { delays } = backoff;
+        return delays[Math.min(this.attempt, delays.length - 1)];
+    }
+}
+// ── HeartbeatMonitor ─────────────────────────────────────────────
+/**
+ * Manages a setInterval-based heartbeat or watchdog timer.
+ *
+ * Replaces duplicated `heartbeatTimer` / `watchdogTimer` patterns:
+ * timer cleanup on re-start, clearInterval on stop.
+ */
+export class HeartbeatMonitor {
+    timer = null;
+    _lastResponseTime = 0;
+    get lastResponseTime() { return this._lastResponseTime; }
+    /** Record that a response was received (for watchdog stale detection). */
+    recordResponse() { this._lastResponseTime = Date.now(); }
+    /**
+     * Start a periodic callback.  Clears any existing timer first.
+     * @param intervalMs  Interval in milliseconds.
+     * @param onTick      Callback invoked on each tick.
+     */
+    start(intervalMs, onTick) {
+        this.stop();
+        this.timer = setInterval(() => {
+            Promise.resolve(onTick()).catch(() => { });
+        }, intervalMs);
+    }
+    /** Clear the heartbeat timer. */
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    /**
+     * Watchdog convenience: returns true if more than `staleMs` have elapsed
+     * since the last `recordResponse()` call.
+     */
+    isStale(staleMs) {
+        return this._lastResponseTime > 0 && Date.now() - this._lastResponseTime > staleMs;
+    }
+}
+// ── StateManager ─────────────────────────────────────────────────
+/**
+ * Manages a connection state variable with change-notification callback.
+ *
+ * Replaces duplicated `connectionState` / `channelState` + `stateChangeHandler`
+ * patterns across wework, clawbot, and workbuddy clients.
+ */
+export class StateManager {
+    _state;
+    onChange;
+    constructor(initialState) {
+        this._state = initialState;
+    }
+    get current() { return this._state; }
+    /** Register a callback invoked whenever the state changes. */
+    setOnChange(handler) {
+        this.onChange = handler;
+    }
+    /** Transition to a new state and notify the callback if it changed. */
+    set(newState) {
+        if (this._state === newState)
+            return;
+        this._state = newState;
+        this.onChange?.(newState);
+    }
+}

package/dist/wework/client.js

@@ -10,26 +10,44 @@
 import { WebSocket } from 'ws';
 import { randomBytes } from 'node:crypto';
 import { createLogger } from '../logger.js';
-import { jitteredDelay, SLOW_PROBE_MS, isFatalReconnectError } from '../shared/reconnect.js';
+import { isFatalReconnectError } from '../shared/reconnect.js';
+import { ReconnectManager, HeartbeatMonitor, StateManager } from '../shared/connection-manager.js';
 const log = createLogger('WeWork');
 const DEFAULT_WS_URL = 'wss://openws.work.weixin.qq.com';
 const HEARTBEAT_INTERVAL = 30000; // 30秒
 const PONG_TIMEOUT = HEARTBEAT_INTERVAL * 3; // 90秒无任何服务端响应则判定连接死亡
-const MAX_RECONNECT_ATTEMPTS = 100;
-// Global state
+// Connection infrastructure (shared managers replace raw timers/counters)
 let ws = null;
-let connectionState = 'disconnected';
-let reconnectTimer = null;
-let heartbeatTimer = null;
-let reconnectAttempts = 0;
+const stateManager = new StateManager('disconnected');
+const heartbeatMonitor = new HeartbeatMonitor();
 let shouldReconnect = false;
 let isStopping = false;
-let lastServerResponseTime = 0; // 上次收到服务端消息的时间
 // Event handlers
 let messageHandler = null;
-let stateChangeHandler = null;
 // Configuration
 let config = null;
+// Reconnect manager: exponential backoff 5s → 7.5s → 11s → ... max 60s
+const reconnectManager = new ReconnectManager({
+    name: 'WeWork',
+    backoff: { mode: 'exponential', baseMs: 5000, maxMs: 60000, cap: 5 },
+    maxAttempts: 100,
+    onReconnect: async () => {
+        log.info('Reconnecting...');
+        try {
+            await connectWebSocket();
+            reconnectManager.setFatal(false); // 连上后恢复正常退避
+        }
+        catch (err) {
+            if (isFatalReconnectError(err)) {
+                reconnectManager.setFatal(true);
+                log.warn('WeWork 致命错误（鉴权失败），转慢探测:', err);
+            }
+            else {
+                log.error('Reconnection failed:', err);
+            }
+        }
+    },
+});
 /**
  * Generate unique request ID
  */
@@ -40,7 +58,7 @@ function generateReqId() {
  * Get current connection state
  */
 export function getConnectionState() {
-    return connectionState;
+    return stateManager.current;
 }
 /**
  * 主动推送消息 (aibot_send_msg)
@@ -48,7 +66,7 @@ export function getConnectionState() {
  * 注意：需用户曾与机器人对话后，才能向该会话主动推送
  */
 export function sendProactiveMessage(chatId, content) {
-    if (!ws || connectionState !== 'connected') {
+    if (!ws || stateManager.current !== 'connected') {
         throw new Error('Cannot send proactive message: WebSocket not connected');
     }
     if (!chatId) {
@@ -77,7 +95,7 @@ export function sendProactiveMessage(chatId, content) {
  * 长连接模式下必须用此方式回复，透传 req_id
  */
 export function sendWebSocketReply(reqId, body) {
-    if (!ws || connectionState !== 'connected') {
+    if (!ws || stateManager.current !== 'connected') {
         throw new Error('Cannot send reply: WebSocket not connected');
     }
     if (!reqId) {
@@ -109,11 +127,13 @@ export async function initWeWork(cfg, eventHandler, onStateChange) {
         websocketUrl: cfg.weworkWsUrl || DEFAULT_WS_URL,
     };
     messageHandler = eventHandler;
-    stateChangeHandler = onStateChange ?? null;
+    stateManager.setOnChange(onStateChange);
     isStopping = false;
     shouldReconnect = false;
+    reconnectManager.reset();
+    reconnectManager.resume();
     log.info('Initializing WeWork client');
-    // 首次连接支持重试：单独启用企微时偶发 TLS 连接失败，加飞书后因初始化顺序有“预热”效果则稳定
+    // 首次连接支持重试：单独启用企微时偶发 TLS 连接失败，加飞书后因初始化顺序有"预热"效果则稳定
     const maxAttempts = 3;
     const retryDelayMs = 1500;
     let lastErr = null;
@@ -136,7 +156,7 @@ export async function initWeWork(cfg, eventHandler, onStateChange) {
  * Connect to WeWork WebSocket server
  */
 async function connectWebSocket() {
-    if (connectionState === 'connecting') {
+    if (stateManager.current === 'connecting') {
         log.warn('WebSocket connection already in progress');
         return;
     }
@@ -154,16 +174,16 @@ async function connectWebSocket() {
         }
         ws = null;
     }
-    updateState('connecting');
+    stateManager.set('connecting');
     const websocketUrl = config.websocketUrl || DEFAULT_WS_URL;
     return new Promise((resolve, reject) => {
         try {
             ws = new WebSocket(websocketUrl);
             ws.on('open', async () => {
                 log.info('WeWork WebSocket connected');
-                reconnectAttempts = 0;
-                updateState('connected');
-                startHeartbeat();
+                reconnectManager.reset();
+                stateManager.set('connected');
+                heartbeatMonitor.start(HEARTBEAT_INTERVAL, heartbeatTick);
                 // 发送认证订阅消息，并等待服务端确认（否则 aibot_send_msg 会报 846609 not subscribed）
                 try {
                     await sendSubscribeAndWaitAck(resolve, reject);
@@ -176,7 +196,7 @@ async function connectWebSocket() {
                 }
             });
             ws.on('message', async (data) => {
-                lastServerResponseTime = Date.now();
+                heartbeatMonitor.recordResponse();
                 try {
                     const message = JSON.parse(data.toString());
                     await handleMessage(message);
@@ -187,21 +207,21 @@ async function connectWebSocket() {
             });
             ws.on('error', (err) => {
                 log.error('WeWork WebSocket error:', err);
-                updateState('error');
+                stateManager.set('error');
                 reject(err);
             });
             ws.on('close', () => {
                 log.info('WeWork WebSocket closed');
-                stopHeartbeat();
-                updateState('disconnected');
+                heartbeatMonitor.stop();
+                stateManager.set('disconnected');
                 if (!isStopping && shouldReconnect) {
-                    scheduleReconnect();
+                    reconnectManager.schedule();
                 }
             });
         }
         catch (err) {
             log.error('Error creating WebSocket connection:', err);
-            updateState('error');
+            stateManager.set('error');
             reject(err);
         }
     });
@@ -279,7 +299,7 @@ async function handleMessage(message) {
  * Send message to WeWork
  */
 export function sendMessage(message) {
-    if (!ws || connectionState !== 'connected') {
+    if (!ws || stateManager.current !== 'connected') {
         log.warn('Cannot send message: WebSocket not connected');
         return;
     }
@@ -319,108 +339,43 @@ export function sendStreamWithItems(reqId, streamId, content, finish, msgItem) {
     });
 }
 /**
- * Update connection state and notify listeners
- */
-function updateState(state) {
-    connectionState = state;
-    if (stateChangeHandler) {
-        stateChangeHandler(state);
-    }
-    log.debug('Connection state:', state);
-}
-/**
- * Start heartbeat to keep connection alive
+ * Heartbeat tick: send ping and detect stale connections.
  * 同时检测服务端是否响应，超时无响应则主动断开触发重连
  */
-function startHeartbeat() {
-    stopHeartbeat();
-    lastServerResponseTime = Date.now();
-    heartbeatTimer = setInterval(() => {
-        if (connectionState === 'connected' && ws) {
-            // 检测连接是否已死：长时间未收到任何服务端响应
-            const elapsed = Date.now() - lastServerResponseTime;
-            if (lastServerResponseTime > 0 && elapsed > PONG_TIMEOUT) {
-                log.warn(`No server response for ${Math.round(elapsed / 1000)}s, forcing reconnect`);
-                stopHeartbeat();
-                try {
-                    ws.removeAllListeners();
-                    ws.close();
-                }
-                catch {
-                    /* ignore */
-                }
-                ws = null;
-                updateState('disconnected');
-                scheduleReconnect();
-                return;
-            }
-            const pingMessage = {
-                cmd: "ping" /* WeWorkCommand.PING */,
-                headers: {
-                    req_id: generateReqId(),
-                },
-                body: {},
-            };
-            try {
-                ws.send(JSON.stringify(pingMessage));
-                log.debug('Sent ping');
-            }
-            catch (err) {
-                log.error('Error sending ping:', err);
-            }
+function heartbeatTick() {
+    if (stateManager.current !== 'connected' || !ws)
+        return;
+    // 检测连接是否已死：长时间未收到任何服务端响应
+    if (heartbeatMonitor.isStale(PONG_TIMEOUT)) {
+        const elapsed = Date.now() - heartbeatMonitor.lastResponseTime;
+        log.warn(`No server response for ${Math.round(elapsed / 1000)}s, forcing reconnect`);
+        heartbeatMonitor.stop();
+        try {
+            ws.removeAllListeners();
+            ws.close();
         }
-    }, HEARTBEAT_INTERVAL);
-}
-/**
- * Stop heartbeat
- */
-function stopHeartbeat() {
-    if (heartbeatTimer) {
-        clearInterval(heartbeatTimer);
-        heartbeatTimer = null;
-    }
-}
-/**
- * Schedule reconnection attempt
- * 超过 MAX_RECONNECT_ATTEMPTS 后自动重置计数器继续重试，避免永久断连
- */
-/** 致命（鉴权）错误后转慢探测，避免紧密 hammer 网关 */
-let fatalSlowProbe = false;
-function scheduleReconnect() {
-    if (isStopping || !shouldReconnect) {
+        catch {
+            /* ignore */
+        }
+        ws = null;
+        stateManager.set('disconnected');
+        reconnectManager.schedule();
         return;
     }
-    if (reconnectTimer) {
-        return;
+    const pingMessage = {
+        cmd: "ping" /* WeWorkCommand.PING */,
+        headers: {
+            req_id: generateReqId(),
+        },
+        body: {},
+    };
+    try {
+        ws.send(JSON.stringify(pingMessage));
+        log.debug('Sent ping');
     }
-    // 超过最大重试次数后重置计数器，降低频率继续重试
-    if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-        log.warn(`Max reconnect attempts (${MAX_RECONNECT_ATTEMPTS}) reached, resetting counter and retrying at lower frequency`);
-        reconnectAttempts = 0;
+    catch (err) {
+        log.error('Error sending ping:', err);
     }
-    // 逐步增加间隔，5s → 7.5s → 11s → ... 最大 60s；致命（鉴权）错误转慢探测
-    const backoff = fatalSlowProbe
-        ? SLOW_PROBE_MS
-        : Math.min(5000 * Math.pow(1.5, Math.floor(reconnectAttempts / 5)), 60000);
-    const interval = jitteredDelay(Math.round(backoff));
-    reconnectTimer = setTimeout(async () => {
-        reconnectTimer = null;
-        reconnectAttempts++;
-        log.info(`Reconnecting... Attempt ${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS} (interval: ${interval}ms${fatalSlowProbe ? ', slow-probe' : ''})`);
-        try {
-            await connectWebSocket();
-            fatalSlowProbe = false; // 连上后恢复正常退避
-        }
-        catch (err) {
-            if (isFatalReconnectError(err)) {
-                fatalSlowProbe = true;
-                log.warn('WeWork 致命错误（鉴权失败），转慢探测:', err);
-            }
-            else {
-                log.error('Reconnection failed:', err);
-            }
-        }
-    }, interval);
 }
 /**
  * Stop WeWork client
@@ -428,15 +383,12 @@ function scheduleReconnect() {
 export function stopWeWork() {
     isStopping = true;
     shouldReconnect = false;
-    stopHeartbeat();
-    if (reconnectTimer) {
-        clearTimeout(reconnectTimer);
-        reconnectTimer = null;
-    }
+    heartbeatMonitor.stop();
+    reconnectManager.stop();
     if (ws) {
         ws.close();
         ws = null;
     }
-    updateState('disconnected');
+    stateManager.set('disconnected');
     log.info('WeWork client stopped');
 }

package/dist/workbuddy/client.js

@@ -9,7 +9,8 @@ import { existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { hostname, homedir } from 'node:os';
 import { createLogger } from '../logger.js';
-import { jitteredDelay, SLOW_PROBE_MS, isFatalReconnectError } from '../shared/reconnect.js';
+import { isFatalReconnectError } from '../shared/reconnect.js';
+import { ReconnectManager, HeartbeatMonitor, StateManager } from '../shared/connection-manager.js';
 import { WorkBuddyOAuth } from './oauth.js';
 import { WorkBuddyCentrifugeClient } from './centrifuge-client.js';
 const log = createLogger('WorkBuddy');
@@ -18,19 +19,29 @@ const CHANNEL_HEARTBEAT_MS = 30_000;
 // Global state
 let oauthClient = null;
 let centrifugeClient = null;
-let channelState = 'disconnected';
 let messageHandler = null;
-let stateChangeHandler = null;
-let heartbeatTimer = null;
-let reconnectTimer = null;
-let reconnectAttempt = 0;
-let fatalSlowProbe = false;
 let stopped = false;
 let platformConfig = null;
 /** 单飞刷新 token 的在途 Promise，避免并发 401 重复刷新 */
 let refreshInFlight = null;
+// Connection infrastructure (shared managers replace raw timers/counters)
+const stateManager = new StateManager('disconnected');
+const heartbeatMonitor = new HeartbeatMonitor();
+const reconnectManager = new ReconnectManager({
+    name: 'WorkBuddy',
+    backoff: { mode: 'stepped', delays: RECONNECT_DELAYS_MS },
+    onReconnect: async () => {
+        try {
+            await connect();
+        }
+        catch (err) {
+            log.error('Reconnect attempt failed:', err);
+            reconnectManager.schedule();
+        }
+    },
+});
 function getChannelState() {
-    return channelState;
+    return stateManager.current;
 }
 export async function initWorkBuddy(config, eventHandler, onStateChange) {
     const pc = config.platforms?.workbuddy;
@@ -42,9 +53,10 @@ export async function initWorkBuddy(config, eventHandler, onStateChange) {
     }
     platformConfig = pc;
     messageHandler = eventHandler;
-    stateChangeHandler = onStateChange ?? null;
+    stateManager.setOnChange(onStateChange);
     stopped = false;
-    reconnectAttempt = 0;
+    reconnectManager.reset();
+    reconnectManager.resume();
     const baseDir = config.logDir ?? join(process.env.HOME ?? '', '.open-im');
     const dataDir = join(baseDir, 'data');
     if (!existsSync(dataDir))
@@ -83,10 +95,10 @@ async function connect() {
     catch (err) {
         log.error('Host workspace registration failed:', err);
         if (isFatalReconnectError(err)) {
-            fatalSlowProbe = true;
+            reconnectManager.setFatal(true);
             log.warn('WorkBuddy 致命错误（鉴权失败），转慢探测（token 可能已过期）:', err);
         }
-        scheduleReconnect();
+        reconnectManager.schedule();
         return;
     }
     // sessionId = userId_hostId_clawPath (matches plugin's buildSessionId format)
@@ -137,9 +149,8 @@ async function connect() {
         onConnected: () => {
             log.info('WorkBuddy Centrifuge connected');
             log.info(`WeChat KF sessionId: ${workspaceSessionId}`);
-            reconnectAttempt = 0;
-            fatalSlowProbe = false;
-            updateState('connected');
+            reconnectManager.reset();
+            stateManager.set('connected');
             // Step 2: Register Claw workspace to get WeChat KF routing channel + sessionId
             oauth.registerWorkspace({
                 userId: pc.userId ?? '',
@@ -152,7 +163,7 @@ async function connect() {
                 // Subscribe to Claw channel — WeChat KF messages are published here
                 centrifugeClient?.subscribeChannel(clawParams.channel, clawParams.subscriptionToken);
                 const doRegister = () => {
-                    if (stopped || channelState !== 'connected')
+                    if (stopped || stateManager.current !== 'connected')
                         return;
                     if (replyLock) {
                         log.debug('Heartbeat skipped (reply in progress)');
@@ -168,14 +179,12 @@ async function connect() {
                         .catch((err) => log.warn(`registerChannel failed: ${String(err)}`));
                 };
                 doRegister();
-                if (heartbeatTimer)
-                    clearInterval(heartbeatTimer);
-                heartbeatTimer = setInterval(doRegister, CHANNEL_HEARTBEAT_MS);
+                heartbeatMonitor.start(CHANNEL_HEARTBEAT_MS, doRegister);
             }).catch((err) => {
                 log.error('Claw workspace registration failed:', err);
                 // Fallback: register with host sessionId
                 const doRegister = () => {
-                    if (stopped || channelState !== 'connected')
+                    if (stopped || stateManager.current !== 'connected')
                         return;
                     if (replyLock) {
                         log.debug('Heartbeat skipped (reply in progress, fallback path)');
@@ -191,19 +200,14 @@ async function connect() {
                         .catch((e) => log.warn(`registerChannel failed: ${String(e)}`));
                 };
                 doRegister();
-                if (heartbeatTimer)
-                    clearInterval(heartbeatTimer);
-                heartbeatTimer = setInterval(doRegister, CHANNEL_HEARTBEAT_MS);
+                heartbeatMonitor.start(CHANNEL_HEARTBEAT_MS, doRegister);
             });
         },
         onDisconnected: (reason) => {
             log.info(`WorkBuddy Centrifuge disconnected: ${reason}`);
-            if (heartbeatTimer) {
-                clearInterval(heartbeatTimer);
-                heartbeatTimer = null;
-            }
-            updateState('disconnected');
-            scheduleReconnect();
+            heartbeatMonitor.stop();
+            stateManager.set('disconnected');
+            reconnectManager.schedule();
         },
         onError: (error) => {
             const msg = error instanceof Error ? error.message : JSON.stringify(error);
@@ -214,16 +218,13 @@ async function connect() {
             else {
                 log.error(`WorkBuddy Centrifuge error: ${msg}`);
             }
-            updateState('error');
+            stateManager.set('error');
         },
         onPersistentFailure: () => {
             log.warn('WorkBuddy Centrifuge persistent failure detected — doing full re-registration');
-            if (heartbeatTimer) {
-                clearInterval(heartbeatTimer);
-                heartbeatTimer = null;
-            }
-            updateState('disconnected');
-            scheduleReconnect();
+            heartbeatMonitor.stop();
+            stateManager.set('disconnected');
+            reconnectManager.schedule();
         },
         onMessage: async (chatId, msgId, content) => {
             if (messageHandler) {
@@ -238,35 +239,6 @@ async function connect() {
     });
     centrifugeClient.start();
 }
-function scheduleReconnect() {
-    if (stopped)
-        return;
-    if (reconnectTimer) {
-        clearTimeout(reconnectTimer);
-        reconnectTimer = null;
-    }
-    const baseDelay = RECONNECT_DELAYS_MS[Math.min(reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)];
-    const delay = fatalSlowProbe ? jitteredDelay(SLOW_PROBE_MS) : jitteredDelay(baseDelay);
-    reconnectAttempt++;
-    log.info(`Reconnecting in ${delay}ms (attempt ${reconnectAttempt})${fatalSlowProbe ? ' [slow-probe]' : ''}...`);
-    reconnectTimer = setTimeout(async () => {
-        reconnectTimer = null;
-        if (stopped)
-            return;
-        try {
-            await connect();
-        }
-        catch (err) {
-            log.error('Reconnect attempt failed:', err);
-            scheduleReconnect();
-        }
-    }, delay);
-}
-function updateState(state) {
-    channelState = state;
-    stateChangeHandler?.(state);
-    log.debug(`WorkBuddy state: ${state}`);
-}
 export function getCentrifugeClient() {
     return centrifugeClient;
 }
@@ -301,20 +273,14 @@ async function refreshWorkBuddyToken() {
 export function stopWorkBuddy() {
     log.info('Stopping WorkBuddy client...');
     stopped = true;
-    if (heartbeatTimer) {
-        clearInterval(heartbeatTimer);
-        heartbeatTimer = null;
-    }
-    if (reconnectTimer) {
-        clearTimeout(reconnectTimer);
-        reconnectTimer = null;
-    }
+    heartbeatMonitor.stop();
+    reconnectManager.stop();
     if (centrifugeClient) {
         centrifugeClient.stop();
         centrifugeClient = null;
     }
     oauthClient = null;
     platformConfig = null;
-    updateState('disconnected');
+    stateManager.set('disconnected');
     log.info('WorkBuddy client stopped');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.11.8-beta.8",
+  "version": "1.11.8-beta.9",
   "description": "Your AI coding assistant, in every chat app. Multi-platform IM bridge for Claude Code, Codex, and CodeBuddy.",
   "type": "module",
   "main": "dist/index.js",