@wu529778790/open-im 1.11.8-beta.2 → 1.11.8-beta.21

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/shared/session-invalid-detector.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unified session-invalid detection — consolidates all session-expiry
+ * error patterns from codex, codebuddy, and opencode into one place.
+ */
+export declare function isSessionInvalidMessage(msg: string): boolean;

package/dist/shared/session-invalid-detector.js

@@ -0,0 +1,20 @@
+/**
+ * Unified session-invalid detection — consolidates all session-expiry
+ * error patterns from codex, codebuddy, and opencode into one place.
+ */
+const SESSION_INVALID_PATTERNS = [
+    'No session found',
+    'No conversation found',
+    'Unable to find session',
+    'Session not found',
+    'Invalid session',
+    'Unable to resume',
+    'session not found',
+    'no sessions found',
+    'session expired',
+    'session corrupt',
+];
+export function isSessionInvalidMessage(msg) {
+    const lower = msg.toLowerCase();
+    return SESSION_INVALID_PATTERNS.some((p) => lower.includes(p.toLowerCase()));
+}

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');
 }