@xgjktech/xg_cwork_im 1.0.0

package/src/channel.ts

@@ -0,0 +1,471 @@
+/**
+ * XG-IM Channel Plugin — 核心定义
+ *
+ * 遵循 OpenClaw Channel Plugin 架构（参考 openclaw-channel-dingtalk）：
+ * - config   : 账户解析
+ * - outbound : AI 回复发送
+ * - gateway  : 启动 WebSocket 长连接，接收 robotMention 消息后通过
+ *              PluginRuntime 路由给 OpenClaw 处理
+ */
+
+import { randomUUID } from "node:crypto";
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { buildChannelConfigSchema } from "openclaw/plugin-sdk";
+import { z } from "zod";
+import { clearTokenCache, getToken } from "./auth.js";
+import { startWebSocket } from "./connection.js";
+import { sendTextMessage } from "./send-service.js";
+import type {
+    GatewayStartContext,
+    PluginRuntime,
+    ResolvedAccount,
+    WsMessage,
+    WsMessageParams,
+    XgImChannelPlugin,
+    XgImConfig,
+} from "./types.js";
+
+// ─── 全局 Runtime（在 index.ts 的 register 中注入）────────────────────────────
+
+let xgImRuntime: PluginRuntime | null = null;
+
+export function setXgImRuntime(rt: PluginRuntime): void {
+    xgImRuntime = rt;
+}
+
+function getXgImRuntime(): PluginRuntime {
+    if (!xgImRuntime) throw new Error("[cwork_im] Plugin runtime not initialized");
+    return xgImRuntime;
+}
+
+// ─── 配置 Schema ──────────────────────────────────────────────────────────────
+
+const XgImAccountConfigSchema = z.object({
+    appKey: z.string().min(1, "appKey is required"),
+    agentId: z.string().optional().default("main"),
+    name: z.string().optional(),
+    groupPolicy: z.enum(["open", "mention"]).optional().default("mention"),
+});
+
+const XgImConfigSchema = z.object({
+    appKey: z.string().optional(),
+    agentId: z.string().optional().default("main"),
+    baseUrl: z.string().url("baseUrl must be a valid URL"),
+    wsBaseUrl: z.string().url("wsBaseUrl must be a valid URL").optional(),
+    enabled: z.boolean().optional().default(true),
+    name: z.string().optional(),
+    groupPolicy: z.enum(["open", "mention"]).optional().default("mention"),
+    allowFrom: z.array(z.string()).optional().default([]),
+    debug: z.boolean().optional().default(false),
+    maxConnectionAttempts: z.number().int().positive().optional().default(10),
+    initialReconnectDelay: z.number().int().positive().optional().default(1_000),
+    maxReconnectDelay: z.number().int().positive().optional().default(60_000),
+    reconnectJitter: z.number().min(0).max(1).optional().default(0.3),
+    accounts: z.array(XgImAccountConfigSchema).optional(),
+});
+
+// ─── 辅助函数 ─────────────────────────────────────────────────────────────────
+
+/** 从顶层 cfg 中取出 XgImConfig，支持多账户（README：channels.xg_cwork_im） */
+function getXgImConfig(cfg: OpenClawConfig, accountId?: string | null): XgImConfig {
+    const raw = (cfg as Record<string, Record<string, unknown>>)?.channels?.xg_cwork_im as XgImConfig | undefined;
+    if (!raw) throw new Error("[cwork_im] channels.xg_cwork_im config not found");
+
+    // 指定了具体账户 ID（数组下标）时，合并对应账户配置
+    if (accountId && accountId !== "default" && raw.accounts) {
+        const accIdx = parseInt(accountId, 10);
+        const sub = raw.accounts[accIdx];
+        if (sub) {
+            return { ...raw, ...sub };
+        }
+    }
+
+    // 没有指定 accountId（如 Cron outbound 场景），自动 fallback 到 accounts[0]
+    // 避免顶层 raw 没有 appKey 时 getToken 失败
+    if (raw.accounts && raw.accounts.length > 0 && !raw.appKey) {
+        return { ...raw, ...raw.accounts[0] };
+    }
+
+    return raw;
+}
+
+function isConfigured(cfg: OpenClawConfig): boolean {
+    try {
+        const c = getXgImConfig(cfg);
+        return Boolean(c?.appKey && c?.baseUrl);
+    } catch {
+        return false;
+    }
+}
+
+// ─── 日志适配器 ───────────────────────────────────────────────────────────────
+// ChannelLogSink 的 info/warn/error 方法接受单个 string
+
+interface Logger {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    debug?: (msg: string) => void;
+}
+
+function toLogger(sink: { info?: (msg: string) => void; warn?: (msg: string) => void; error?: (msg: string) => void; debug?: (msg: string) => void } | undefined): Logger {
+    return {
+        info: (msg) => sink?.info?.(msg),
+        warn: (msg) => sink?.warn?.(msg),
+        error: (msg) => sink?.error?.(msg),
+        debug: (msg) => sink?.debug?.(msg),
+    };
+}
+
+// ─── Channel Plugin 定义 ─────────────────────────────────────────────────────
+
+export const xgCworkImChannelPlugin: XgImChannelPlugin = {
+    id: "xg_cwork_im",
+    meta: {
+        id: "xg_cwork_im",
+        label: "XG CWork IM",
+        selectionLabel: "XG CWork IM (小橙工作台)",
+        docsPath: "/channels/xg_cwork_im",
+        blurb: "小橙工作台 IM 机器人，通过 WebSocket 长连接接收 @ 消息。",
+        aliases: ["xg_cwork_im", "xgim", "im"],
+    },
+    // 双重类型转换绕过 zod v3/v4 的 TS 类型不兼容
+    // buildChannelConfigSchema 会将 schema 包装成可序列化的形式，避免 DataCloneError
+    configSchema: buildChannelConfigSchema(XgImConfigSchema as unknown as Parameters<typeof buildChannelConfigSchema>[0]),
+    capabilities: {
+        chatTypes: ["group"] as Array<"direct" | "group">,
+        reactions: false,
+        threads: false,
+        media: false,
+        nativeCommands: false,
+        blockStreaming: false,
+    },
+    reload: { configPrefixes: ["channels.xg_cwork_im"] },
+
+    // ── 账户配置 ────────────────────────────────────────────────────────────────
+    config: {
+        listAccountIds: (cfg: OpenClawConfig): string[] => {
+            try {
+                const config = getXgImConfig(cfg);
+                if (config.accounts && config.accounts.length > 0) {
+                    // 使用数组下标作为 ID
+                    return config.accounts.map((_, i) => i.toString());
+                }
+                return isConfigured(cfg) ? ["default"] : [];
+            } catch {
+                return [];
+            }
+        },
+
+        resolveAccount: (cfg: OpenClawConfig, accountId?: string | null): ResolvedAccount => {
+            const id = accountId || "default";
+            try {
+                const config = getXgImConfig(cfg, id);
+                return {
+                    accountId: id,
+                    config,
+                    enabled: config.enabled !== false,
+                    configured: Boolean(config.appKey && config.baseUrl),
+                    name: config.name ?? null,
+                };
+            } catch {
+                return {
+                    accountId: id,
+                    config: {} as XgImConfig,
+                    enabled: false,
+                    configured: false,
+                    name: null,
+                };
+            }
+        },
+
+        defaultAccountId: (): string => "default",
+
+        isConfigured: (account: ResolvedAccount): boolean => account.configured,
+
+        describeAccount: (account: ResolvedAccount) => ({
+            accountId: account.accountId,
+            name: account.config?.name ?? "XG-IM",
+            enabled: account.enabled,
+            configured: account.configured,
+        }),
+    },
+
+    // ── 群聊设置 ─────────────────────────────────────────────────────────────────
+    groups: {
+        resolveRequireMention: (params): boolean => {
+            try {
+                const config = getXgImConfig(params.cfg, params.accountId);
+                return config?.groupPolicy !== "open";
+            } catch {
+                return true; // 默认需要 @
+            }
+        },
+    },
+
+    // ── 出站消息（openclaw 主动发送时调用）────────────────────────────────────────
+    outbound: {
+        deliveryMode: "direct" as const,
+
+        resolveTarget: (params) => {
+            const trimmed = params.to?.trim();
+            if (!trimmed) {
+                return {
+                    ok: false as const,
+                    error: new Error("XG-IM message requires --to <groupId>"),
+                };
+            }
+            return { ok: true as const, to: trimmed };
+        },
+
+        sendText: async (ctx) => {
+            const { cfg, to, text, accountId } = ctx;
+            const log: Logger = { info: () => { }, warn: () => { }, error: () => { }, debug: () => { } };
+            const config = getXgImConfig(cfg, accountId);
+            const identity = await getToken(config, log);
+
+            await sendTextMessage(config, identity.token, to, text, [], log);
+
+            return {
+                channel: "xg_cwork_im",
+                messageId: randomUUID(),
+            };
+        },
+    },
+
+    // ── 网关（WebSocket 长连接）─────────────────────────────────────────────────
+    gateway: {
+        startAccount: async (ctx: GatewayStartContext): Promise<void> => {
+            const account = ctx.account;
+            const config = account.config;
+            const log = toLogger(ctx.log);
+            const logPrefix = `[${account.accountId}:${config.agentId || "main"}]`;
+
+            if (!config.appKey || !config.baseUrl) {
+                throw new Error(`${logPrefix} appKey and baseUrl are required in config`);
+            }
+
+            log.info(`${logPrefix} Starting XG-IM channel...`);
+
+            // 1. 获取机器人 token（有效期一年，缓存后无需重复请求）
+            const identity = await getToken(config, log);
+
+            // 2. 获取 PluginRuntime（用于路由消息给 OpenClaw）
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const rt = getXgImRuntime() as any;
+
+            // 3. 若 abort 信号已触发则不启动
+            if (ctx.abortSignal?.aborted) {
+                throw new Error(`${logPrefix} Connection aborted before start`);
+            }
+
+            // 4. 消息去重（按账户隔离）
+            const processedMsgIds = new Set<string>();
+            const MSG_DEDUP_MAX = 1_000;
+
+            const isDuplicate = (msgId: string): boolean => {
+                if (processedMsgIds.has(msgId)) return true;
+                if (processedMsgIds.size >= MSG_DEDUP_MAX) {
+                    const iter = processedMsgIds.values();
+                    for (let i = 0; i < MSG_DEDUP_MAX / 2; i++) {
+                        const val = iter.next().value;
+                        if (val !== undefined) processedMsgIds.delete(val);
+                    }
+                }
+                processedMsgIds.add(msgId);
+                return false;
+            };
+
+            // 5. 收到 WebSocket 消息时的处理逻辑
+            const handleMessage = async (msg: WsMessage): Promise<void> => {
+                const params = msg.params;
+                try {
+                    if (isDuplicate(params.msgId)) {
+                        log.debug?.(`${logPrefix} Duplicate msgId=${params.msgId}, skipping`);
+                        return;
+                    }
+
+                    const msgContent = params.msgContent;
+                    const msgType = msgContent?.type ?? "text";
+                    const msgUrl = msgContent?.url;
+                    const msgExt = msgContent?.ext;
+
+                    let rawText = msgContent?.text ?? "";
+                    // 如果是语音消息且没有文本内容，设为占位符
+                    if (msgType === "voice" && !rawText) {
+                        rawText = "[语音消息]";
+                    }
+                    const text = rawText;
+
+                    if (!text && !msgUrl) {
+                        log.debug?.(`${logPrefix} Empty message (no text and no url), skipping`);
+                        return;
+                    }
+
+                    log.info(
+                        `${logPrefix} Message from ${params.fromUserName}(${params.fromUserId}) in group=${params.groupId}: ${text}`,
+                    );
+
+                    // 1. 获取当前机器人身份
+                    const currentIdentity = await getToken(config, log);
+                    // 2. 判定是否真正 @ 了当前机器人
+                    const isMentioned = Array.isArray(params.mentions) &&
+                        params.mentions.includes(currentIdentity.userId);
+
+                    // (补充逻辑) 如果是 robotMention 指令，但没有 mentions 列表，则降级为老逻辑：文本正则匹配
+                    const isLegacyMentioned = msg.cmd === "robotMention" &&
+                        (!params.mentions || params.mentions.length === 0) &&
+                        new RegExp(`@${currentIdentity.name}\\b`).test(rawText);
+
+                    const actuallyMentioned = isMentioned || isLegacyMentioned;
+
+                    // 3. 构建 OpenClaw 视角的“单条纯净消息”
+
+                    // 通过 PluginRuntime 路由消息到 OpenClaw
+                    const route = rt.channel.routing.resolveAgentRoute({
+                        cfg: ctx.cfg,
+                        channel: "xg_cwork_im",
+                        accountId: account.accountId,
+                        agentId: config.agentId || "main",
+                        peer: { kind: "group", id: params.groupId },
+                    });
+                    log.info(`${logPrefix} [route] agentId=${route.agentId} sessionKey=${route.sessionKey}`);
+
+                    const storePath = rt.channel.session.resolveStorePath(ctx.cfg.session?.store, {
+                        agentId: route.agentId,
+                    });
+
+                    const envelopeOptions = rt.channel.reply.resolveEnvelopeFormatOptions(ctx.cfg);
+                    const previousTimestamp = rt.channel.session.readSessionUpdatedAt({
+                        storePath,
+                        sessionKey: route.sessionKey,
+                    });
+
+                    const msgTime = params.timestamp ?? params.msgSendTime ?? 0;
+                    const fromLabel = `${params.groupId} - ${params.fromUserName}`;
+                    const body = rt.channel.reply.formatInboundEnvelope({
+                        channel: "XG-IM",
+                        from: fromLabel,
+                        timestamp: msgTime,
+                        body: text,
+                        chatType: "group",
+                        sender: { name: params.fromUserName, id: params.fromUserId },
+                        previousTimestamp,
+                        envelope: envelopeOptions,
+                    });
+
+                    const inboundCtx = rt.channel.reply.finalizeInboundContext({
+                        Body: body,
+                        RawBody: text,
+                        CommandBody: text,
+                        From: params.groupId,
+                        To: params.groupId,
+                        SessionKey: route.sessionKey,
+                        AccountId: account.accountId,
+                        ChatType: "group",
+                        ConversationLabel: fromLabel,
+                        GroupSubject: params.groupId,
+                        SenderName: params.fromUserName,
+                        SenderId: params.fromUserId,
+                        Provider: "xg_cwork_im",
+                        Surface: "xg_cwork_im",
+                        MessageSid: params.msgId,
+                        Timestamp: msgTime,
+                        OriginatingChannel: "xg_cwork_im",
+                        OriginatingTo: params.groupId,
+                        GroupChannel: route.sessionKey,
+                        // 透传媒体信息
+                        MediaUrl: msgUrl,
+                        MediaType: msgType === "voice" ? "voice" : undefined,
+                        // 透传扩展字段给 AI (作为 UntrustedContext)
+                        UntrustedContext: msgExt ? [JSON.stringify(msgExt)] : undefined,
+                        // 同时保留原始 ext 供可能的后续逻辑使用
+                        XgImExt: msgExt,
+                    });
+
+                    // 【所有消息都必须做】记录到数据库！让 AI 产生“记忆”
+                    log.info(`${logPrefix} [session] Recording inbound session sessionKey=${inboundCtx.SessionKey || route.sessionKey}`);
+                    await rt.channel.session.recordInboundSession({
+                        storePath,
+                        sessionKey: inboundCtx.SessionKey || route.sessionKey,
+                        ctx: inboundCtx,
+                        updateLastRoute: {
+                            sessionKey: route.mainSessionKey,
+                            channel: "xg_cwork_im",
+                            to: params.groupId,
+                            accountId: account.accountId,
+                        },
+                        onRecordError: (err: unknown) => {
+                            log.error(`${logPrefix} Failed to record session: ${String(err)}`);
+                        },
+                    });
+
+                    // 【只有真 @ 我的消息才做】呼叫 AI 激活推理
+                    if (actuallyMentioned) {
+                        log.info(`${logPrefix} [dispatch] Dispatching to OpenClaw AI, sessionKey=${route.sessionKey}`);
+                        let isFirstReply = true;
+                        const dispatchStart = Date.now();
+
+                        // 分发消息给 AI，deliver 回调负责发送回复
+                        await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+                            ctx: inboundCtx,
+                            cfg: ctx.cfg,
+                            dispatcherOptions: {
+                                responsePrefix: "",
+                                deliver: async (payload: { markdown?: string; text?: string }) => {
+                                    try {
+                                        const textToSend = payload.markdown || payload.text;
+                                        if (!textToSend) return;
+
+                                        if (isFirstReply) {
+                                            const ttfr = Date.now() - dispatchStart;
+                                            log.info(`${logPrefix} [deliver] First response block received from AI (TTFB: ${ttfr}ms)`);
+                                            isFirstReply = false;
+                                        }
+
+                                        log.info(`${logPrefix} [deliver] Sending block to groupId=${params.groupId} length=${textToSend.length}`);
+                                        await sendTextMessage(
+                                            config,
+                                            currentIdentity.token,
+                                            params.groupId,
+                                            textToSend,
+                                            [params.fromUserId] as string[],
+                                            log,
+                                        );
+                                        log.info(`${logPrefix} [deliver] Block sent successfully to groupId=${params.groupId}`);
+                                    } catch (err: unknown) {
+                                        log.error(`${logPrefix} Reply deliver failed: ${String(err)}`);
+                                        throw err;
+                                    }
+                                },
+                            },
+                        });
+                        log.info(`${logPrefix} [dispatch] Dispatch completed for sessionKey=${route.sessionKey}`);
+                    } else {
+                        // 没 @ 我，仅作为旁观者缓存记忆，不打扰群里聊天
+                        log.debug?.(`${logPrefix} Not mentioned in group, quietly memorized the message context.`);
+                    }
+                } catch (err: unknown) {
+                    log.error(`${logPrefix} handleMessage error: ${String(err)}`);
+                }
+            };
+
+            // 5. 启动 WebSocket 连接
+            const wsHandle = startWebSocket(config, identity.token, handleMessage, log);
+
+            // 6. 阻塞到 abortSignal 触发
+            await new Promise<void>((resolve) => {
+                const abortHandler = (): void => {
+                    log.info(`${logPrefix} Abort signal received, stopping XG-IM channel...`);
+                    wsHandle.stop();
+                    clearTokenCache(config);
+                    resolve();
+                };
+
+                if (ctx.abortSignal) {
+                    ctx.abortSignal.addEventListener("abort", abortHandler, { once: true });
+                }
+            });
+        },
+    },
+};

package/src/connection.ts

@@ -0,0 +1,212 @@
+/**
+ * XG-IM WebSocket 连接管理模块
+ *
+ * 功能：
+ * - 建立 wss://<baseUrl>/ws-notify/websocket?accessToken=<token> 长连接
+ * - 接收 robotMention 消息并回调
+ * - 指数退避 + 抖动的自动重连机制
+ * - 主动发送 WebSocket ping 保活，超时自动重连
+ */
+
+import WebSocket from "ws";
+import type { Log } from "./auth.js";
+import type { WsMessage, WsMessageParams, XgImConfig } from "./types.js";
+
+export type OnMessageCallback = (msg: WsMessage) => void;
+
+/** 心跳间隔（ms）：每 30 秒发一次 ping，防止连接被后台剔除 */
+const PING_INTERVAL_MS = 30_000;
+
+/** 计算指数退避延迟（带随机抖动） */
+function calcDelay(
+    attempt: number,
+    initial: number,
+    max: number,
+    jitter: number,
+): number {
+    const base = Math.min(initial * 2 ** attempt, max);
+    const jitterMs = base * jitter * Math.random();
+    return Math.round(base + jitterMs);
+}
+
+/**
+ * 启动 WebSocket 连接并监听消息。
+ *
+ * @returns 一个 `stop()` 函数，调用后永久断开连接，不再重连。
+ */
+export function startWebSocket(
+    config: XgImConfig,
+    token: string,
+    onMessage: OnMessageCallback,
+    log: Log,
+): { stop: () => void } {
+    const maxAttempts = config.maxConnectionAttempts ?? 10;
+    const initialDelay = config.initialReconnectDelay ?? 1_000;
+    const maxDelay = config.maxReconnectDelay ?? 60_000;
+    const jitter = config.reconnectJitter ?? 0.3;
+    const logPrefix = `[cwork_im:${config.agentId || "main"}]`;
+
+    // 将 baseUrl 的 http/https 协议替换为 ws/wss，并根据业务规则处理独立域名
+    let wsBase = config.wsBaseUrl;
+    if (!wsBase) {
+        // 自动映射逻辑：
+        // https://test.xgjktech.com.cn -> wss://websocket.xgjktech.com.cn
+        // https://xg.mediportal.com.cn -> wss://websocket.mediportal.com.cn
+        wsBase = config.baseUrl
+            .replace(/^http/, "ws");
+    }
+
+    const wsUrl = `${wsBase}/ws-notify/websocket?accessToken=${encodeURIComponent(token)}`;
+
+    let stopped = false;
+    let ws: WebSocket | null = null;
+    let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+    let pingTimer: ReturnType<typeof setInterval> | null = null;
+    let attempt = 0;
+
+    /** 清除心跳定时器 */
+    function clearHeartbeat(): void {
+        if (pingTimer !== null) {
+            clearInterval(pingTimer);
+            pingTimer = null;
+        }
+    }
+
+    /** 启动心跳：每 30s 发一次 ping */
+    function startHeartbeat(socket: WebSocket): void {
+        clearHeartbeat();
+
+        pingTimer = setInterval(() => {
+            if (socket.readyState !== WebSocket.OPEN) {
+                clearHeartbeat();
+                return;
+            }
+
+            const now = new Date().toISOString();
+            log.info(`${logPrefix} ♥ Ping sent at ${now}`);
+
+            // 发送标准 WebSocket ping 帧
+            socket.ping((err: Error | null) => {
+                if (err) {
+                    log.error(`${logPrefix} Ping frame error: ${err.message}`);
+                }
+            });
+
+            // 发送业务层文本 ping（更新服务端活跃时间）
+            socket.send("ping");
+        }, PING_INTERVAL_MS);
+    }
+
+    function connect(): void {
+        if (stopped) return;
+
+        log.info(`${logPrefix} Connecting to WebSocket (attempt ${attempt + 1})...`);
+
+        ws = new WebSocket(wsUrl);
+
+        ws.on("open", () => {
+            attempt = 0; // 连接成功后重置重试计数
+            log.info(`${logPrefix} WebSocket connected successfully.`);
+            startHeartbeat(ws!);
+        });
+
+        // 处理消息
+        ws.on("message", (raw: WebSocket.RawData) => {
+            const rawString = raw.toString();
+
+            if (rawString === "pong" || rawString === "ping") {
+                if (config.debug) log.debug?.(`${logPrefix} Ignored plain text ${rawString}`);
+                return;
+            }
+
+            let parsed: WsMessage;
+            try {
+                parsed = JSON.parse(rawString) as WsMessage;
+            } catch {
+                // 如果不是 JSON，说明是心跳或者其他内容，忽略即可
+                // 如果开启 debug 还是可以打印日志
+                if (config.debug) {
+                    log.debug?.(`${logPrefix} Received non-JSON message: ${rawString.slice(0, 50)}`);
+                }
+                return;
+            }
+
+            log.info(`${logPrefix} ⇐ WS message received: cmd=${parsed.cmd}`);
+
+            // 这块不需要了，因为上面已经处理了纯文本 pong
+
+
+            // 处理包含 params 的事件（无论是 robotMention 还是普通 message）
+            if (parsed.params && (parsed.cmd === "robotMention" || parsed.cmd === "groupMessage")) {
+                if (parsed.cmd === "robotMention") {
+                    log.info(`${logPrefix} 📨 robotMention received: groupId=${parsed.params.groupId} msgId=${parsed.params.msgId}`);
+                }
+                // onMessage 是 async 函数，必须用 .catch() 捕获异步错误
+                // 否则 await 之后的错误会变成未处理的 Promise rejection 被静默丢弃
+                Promise.resolve(onMessage(parsed)).catch((err: unknown) => {
+                    log.error(`${logPrefix} onMessage async error: ${String(err)}`);
+                });
+            }
+        });
+
+        ws.on("close", (code: number, reason: Buffer) => {
+            clearHeartbeat();
+            if (stopped) {
+                log.info(`${logPrefix} WebSocket closed (intentional stop).`);
+                return;
+            }
+            const reasonStr = (reason && reason.length > 0) ? reason.toString() : "(none)";
+
+            // 使用 log.info 输出警告，避免 log.warn 不存在导致漏打日志
+            log.info(`${logPrefix} [WARN] WebSocket closed unexpectedly: code=${code}, reason=${reasonStr}. Scheduling reconnect...`);
+            scheduleReconnect();
+        });
+
+        ws.on("error", (err: Error) => {
+            if (stopped) return;
+            log.error(`${logPrefix} WebSocket error: ${err.message}`);
+            // 关闭后会触发 close 事件，由 close 处理重连
+        });
+    }
+
+    function scheduleReconnect(): void {
+        if (stopped) return;
+
+        if (attempt >= maxAttempts) {
+            log.error(`${logPrefix} Max reconnect attempts (${maxAttempts}) reached. Giving up.`);
+            return;
+        }
+
+        const delay = calcDelay(attempt, initialDelay, maxDelay, jitter);
+        attempt += 1;
+        log.info(`${logPrefix} Reconnecting in ${delay}ms (attempt ${attempt}/${maxAttempts})...`);
+
+        reconnectTimer = setTimeout(() => {
+            reconnectTimer = null;
+            connect();
+        }, delay);
+    }
+
+    // 首次连接
+    connect();
+
+    return {
+        stop(): void {
+            if (stopped) return;
+            stopped = true;
+            log.info(`${logPrefix} Stopping WebSocket connection...`);
+
+            clearHeartbeat();
+
+            if (reconnectTimer !== null) {
+                clearTimeout(reconnectTimer);
+                reconnectTimer = null;
+            }
+
+            if (ws && ws.readyState !== WebSocket.CLOSED) {
+                ws.close(1000, "Plugin stopped");
+            }
+            ws = null;
+        },
+    };
+}