@workclaw/openclaw-workclaw 1.0.23 → 1.0.26

package/dist/src/gateway/reconnect.js

@@ -1,210 +0,0 @@
-/**
- * Reconnect Scheduler - manages WebSocket reconnection with exponential backoff
- */
-import { clearWorkclawTokenCache } from "../connection/workclaw-client.js";
-import { openWorkclawConnection } from "../connection/workclaw-client.js";
-import { Agent, WebSocket } from "undici";
-import { setWorkclawWsConnection, clearWorkclawWsConnection } from "../runtime.js";
-export function createReconnectScheduler(options) {
-    const { key, config, log, onMessage, onReconnectSuccess, onClose, onConnectingStarted } = options;
-    let reconnectBackoff = 5000;
-    let shouldStopReconnect = false;
-    let pendingReconnectTimer = null;
-    /** 正在进行的 doConnect() 的 promise，所有 caller 共享同一个结果 */
-    let pendingDoConnectPromise = null;
-    /**
-     * 核心建连逻辑，首次连接和重连复用同一套代码
-     * 返回 Promise，连接建立后 resolve，失败后决定是否重连
-     * 关键：重试时复用 pendingDoConnectPromise，所有 caller 共享同一个结果
-     *  - 失败时：不删除 promise，让后续 connect() 调用者等待重试结果
-     *  - 重试定时器触发时：复用同一 promise，不创建新的
-     */
-    async function doConnect() {
-        // 如果已有进行中的 doConnect（失败后重试期间），复用同一 promise
-        if (pendingDoConnectPromise !== null) {
-            return pendingDoConnectPromise;
-        }
-        let resolveThis;
-        let rejectThis;
-        const p = new Promise((resolve, reject) => {
-            resolveThis = resolve;
-            rejectThis = reject;
-        });
-        // 设置后再调用 connection，后续 connect() 调用能立即看到它
-        pendingDoConnectPromise = p;
-        const tokenCacheKey = config.appKey || key;
-        clearWorkclawTokenCache(tokenCacheKey);
-        const connConfig = {
-            baseUrl: config.baseUrl || "",
-            websocketUrl: config.websocketUrl,
-            appKey: config.appKey,
-            appSecret: config.appSecret,
-            localIp: config.localIp,
-            allowInsecureTls: config.allowInsecureTls,
-            requestTimeout: config.requestTimeout,
-        };
-        let endpoint;
-        let ticket;
-        try {
-            const result = await openWorkclawConnection(tokenCacheKey, connConfig);
-            endpoint = result.endpoint;
-            ticket = result.ticket;
-        }
-        catch (err) {
-            // openWorkclawConnection 失败时（如 AbortError），由 handleConnectError 决定是否重试
-            // 如果不重试则 reject promise；如果重试则保持 pending（后续 timer 会触发重试）
-            const willRetry = handleConnectError(String(err));
-            if (!willRetry) {
-                pendingDoConnectPromise = null;
-                rejectThis(err);
-            }
-            throw err;
-        }
-        const url = `${endpoint}?ticket=${encodeURIComponent(ticket)}`;
-        const dispatcher = connConfig.allowInsecureTls
-            ? new Agent({ connect: { rejectUnauthorized: false } })
-            : undefined;
-        const wsOptions = dispatcher ? { dispatcher } : undefined;
-        const ws = new WebSocket(url, wsOptions);
-        setWorkclawWsConnection(key, ws);
-        // 在 onopen 之前调用，让 waitForConnect() 释放锁
-        onConnectingStarted?.(ws);
-        // 统一用 resolveThis/rejectThis，ws.onopen 调用 resolveThis 让 await Promise 完成
-        ws.onopen = () => {
-            log?.info?.(`Gateway WebSocket connected endpoint=${endpoint}`);
-            reconnectBackoff = 5000;
-            onReconnectSuccess?.();
-            resolveThis();
-        };
-        ws.onerror = (event) => {
-            log?.error?.(`Gateway WebSocket error: ${String(event?.message ?? event)}`);
-            rejectThis(new Error(String(event?.message ?? event)));
-        };
-        ws.onclose = (event) => {
-            const code = String(event?.code ?? "");
-            const reason = String(event?.reason ?? "");
-            log?.warn?.(`Gateway WebSocket closed code=${code} reason=${reason}`);
-            clearWorkclawWsConnection(key);
-            if (onClose) {
-                onClose();
-            }
-            else {
-                scheduleReconnect();
-            }
-            rejectThis(new Error(`WebSocket closed code=${code} reason=${reason}`));
-        };
-        ws.onmessage = (event) => {
-            const data = typeof event.data === "string" ? event.data : String(event.data ?? "");
-            log?.info?.(`Gateway WebSocket message received bytes=${data.length}`);
-            onMessage(data);
-        };
-        // 等待 ws.onopen 完成（resolveThis）或 ws.onerror/ws.onclose 失败（rejectThis）
-        await new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => reject(new Error("websocket connection timeout")), 30000);
-            ws.addEventListener("open", () => { clearTimeout(timeout); resolve(); }, { once: true });
-            ws.addEventListener("error", (event) => { clearTimeout(timeout); reject(new Error(String(event?.message ?? event))); }, { once: true });
-            ws.addEventListener("close", (event) => { clearTimeout(timeout); reject(new Error(`websocket closed before ready code=${event?.code ?? ""} reason=${event?.reason ?? ""}`)); }, { once: true });
-        });
-    }
-    const scheduleReconnect = () => {
-        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;
-            // 清除旧的 pendingDoConnectPromise，确保 doConnect() 真正建立新连接
-            // 否则 doConnect() 会直接返回已 resolved 的旧 promise（第一次失败后 promise 没被清除）
-            pendingDoConnectPromise = null;
-            try {
-                log?.info?.(`Reconnect: Attempting... key=${key}`);
-                await doConnect();
-                log?.info?.(`Reconnect: Success`);
-            }
-            catch (err) {
-                const errorStr = String(err);
-                log?.error?.(`Reconnect: Failed: ${errorStr}`);
-                const willRetry = handleConnectError(errorStr);
-                if (!willRetry) {
-                    // 永久失败，清除 pending promise
-                    pendingDoConnectPromise = null;
-                }
-                else {
-                    // 错误不代表永久失败，调度下一次重连
-                    scheduleReconnect();
-                }
-            }
-        }, delayMs);
-    };
-    /** 返回 true=会重试（promise 保持 pending），false=不重试（promise 应被 reject） */
-    function handleConnectError(errorStr) {
-        if (errorStr.includes("访问过于频繁")) {
-            log?.warn?.(`Reconnect: Rate limited, retrying with minimal backoff`);
-            if (pendingReconnectTimer !== null) {
-                clearTimeout(pendingReconnectTimer);
-                pendingReconnectTimer = null;
-            }
-            reconnectBackoff = 1000;
-            scheduleReconnect();
-            return true; // 会重试
-        }
-        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 false; // 不重试
-        }
-        // 其他错误：重试
-        return true;
-    }
-    /**
-     * 首次连接或重连：调用 doConnect()，返回其 promise
-     * 如果 doConnect() 因失败正在重试（promise 仍 pending），返回同一 promise
-     * 调用方 await 此方法，连接建立后 resolve，失败且不重试时 reject
-     */
-    async function connect() {
-        // 如果 doConnect() 正在进行中（失败后重试期间），返回同一 promise 让 caller 等待
-        if (pendingDoConnectPromise !== null) {
-            return pendingDoConnectPromise;
-        }
-        try {
-            return await doConnect();
-        }
-        catch (err) {
-            const errorStr = String(err);
-            log?.error?.(`Gateway connect failed: ${errorStr}`);
-            const willRetry = handleConnectError(errorStr);
-            if (!willRetry) {
-                // 不重试时，清除 pending promise，后续 connect() 可创建新的
-                pendingDoConnectPromise = null;
-                throw err;
-            }
-            // handleConnectError 返回 true 时，安排后续重试
-            // 注意：pendingDoConnectPromise 仍 pending，下次定时器触发时会清除它再真正重连
-            scheduleReconnect();
-        }
-    }
-    const stopReconnect = () => {
-        shouldStopReconnect = true;
-        if (pendingReconnectTimer !== null) {
-            clearTimeout(pendingReconnectTimer);
-            pendingReconnectTimer = null;
-        }
-    };
-    return { connect, scheduleReconnect, stopReconnect };
-}