opencode-dingtalk 0.2.0

package/dist/dingtalk/bot.js

@@ -0,0 +1,2129 @@
+import { randomUUID } from "node:crypto";
+import { acquireBotLock, releaseBotLock } from "../lock.js";
+import { logger } from "../logger.js";
+import { AICardStatus, } from "../state.js";
+import { getAccessToken, splitMessage, detectMarkdownAndExtractTitle, ensureMarkdownLineBreaks, getPrimaryAgentNames, cycleAgentName, getAgentModel, } from "../utils.js";
+import { ConnectionManager, ConnectionState } from "../connection-manager.js";
+import { MessageQueue, QueueType } from "../message-queue.js";
+import { sendTextMessage, sendMarkdownMessage, } from "./dingtalk-api.js";
+import { TOPIC_ROBOT } from "./types.js";
+import { DingTalkClient } from "./dingtalk-client.js";
+import fs from "node:fs";
+// ============ Debug Logger ============
+/**
+ * 调试日志 - 写入文件便于排查问题
+ * 设置环境变量 OPENCODE_DINGTALK_DEBUG_DIR 可自定义日志目录
+ */
+function debugLog(...args) {
+    const logDir = process.env.OPENCODE_DINGTALK_DEBUG_DIR || "/tmp";
+    const logFile = `${logDir}/opencode-dingtalk-debug.log`;
+    const timestamp = new Date().toISOString();
+    const message = args
+        .map((a) => (typeof a === "object" ? JSON.stringify(a) : String(a)))
+        .join(" ");
+    const line = `[${timestamp}] ${message}\n`;
+    try {
+        fs.appendFileSync(logFile, line);
+    }
+    catch {
+        // 忽略文件写入错误
+    }
+    // 同时打印到控制台
+    //logger.log('[opencode-dingtalk-debug]', ...args);
+}
+// ============ Constants ============
+const DINGTALK_API = "https://api.dingtalk.com";
+const CARD_CACHE_TTL = 60 * 60 * 1000; // 1 hour
+// ============ Message Deduplication ============
+const MESSAGE_DEDUP_TTL = 5 * 60 * 1000;
+const MESSAGE_DEDUP_CLEANUP_THRESHOLD = 100;
+function cleanupProcessedMessages(state) {
+    const now = Date.now();
+    for (const [msgId, timestamp] of state.processedInbound.entries()) {
+        if (now - timestamp > MESSAGE_DEDUP_TTL) {
+            state.processedInbound.delete(msgId);
+        }
+    }
+}
+function isMessageProcessed(state, messageId) {
+    return state.processedInbound.has(messageId);
+}
+function markMessageProcessed(state, messageId) {
+    state.processedInbound.set(messageId, Date.now());
+    if (state.processedInbound.size >= MESSAGE_DEDUP_CLEANUP_THRESHOLD) {
+        cleanupProcessedMessages(state);
+    }
+}
+// ============ Group Chat Helpers ============
+/**
+ * 解析群聊消息，提取实际内容和 @ 状态
+ */
+function parseGroupMessage(text, atList, isAtAll, chatbotUserId, mention, mentionAll) {
+    const originalText = text.trim();
+    // 钉钉群聊消息，text 字段可能只包含实际内容，不包含 @部分
+    // 需要通过其他方式判断是否 @了机器人
+    // 检测是否 @所有人
+    let parsedIsAtAll = isAtAll || mentionAll || false;
+    // 检测是否 @了机器人
+    let isAtBot = false;
+    // 方式1: 检查 isAtAll 字段
+    if (isAtAll || mentionAll) {
+        parsedIsAtAll = true;
+    }
+    // 方式2: 检查 atList 是否包含机器人的 userId
+    if (atList && chatbotUserId) {
+        isAtBot = atList.includes(chatbotUserId);
+    }
+    // 方式3: 检查 mention 字段（某些版本的钉钉）
+    if (mention && chatbotUserId) {
+        isAtBot = mention.includes(chatbotUserId);
+    }
+    // 方式4: 检查文本是否以 @ 开头（有些钉钉版本会包含 @文本）
+    if (originalText.startsWith("@")) {
+        isAtBot = true;
+    }
+    // 方式5: 检查文本中是否包含 @所有人
+    if (originalText.includes("@所有人")) {
+        parsedIsAtAll = true;
+    }
+    // 清理内容
+    let cleanContent = originalText;
+    // 去除 @所有人
+    if (parsedIsAtAll) {
+        cleanContent = cleanContent.replace(/@所有人\s*/g, "").trim();
+    }
+    // 去除 @机器人的文本（如果文本中包含）
+    if (isAtBot && originalText.startsWith("@")) {
+        cleanContent = cleanContent.replace(/^@\S+[\s\n]*/, "").trim();
+    }
+    // 如果清理后为空，使用原始文本
+    if (!cleanContent) {
+        cleanContent = originalText;
+    }
+    // 调试日志
+    debugLog("[Group] parseGroupMessage result:", {
+        originalText,
+        atList,
+        isAtAll,
+        mention,
+        mentionAll,
+        chatbotUserId,
+        isAtBot,
+        parsedIsAtAll,
+        cleanContent,
+    });
+    return {
+        cleanContent,
+        isAtBot,
+        isAtAll: parsedIsAtAll,
+    };
+}
+/**
+ * 构建群聊消息历史上下文，用于大模型判断相关性
+ */
+function buildGroupContext(state, conversationId) {
+    const history = state.getGroupMessageHistory(conversationId);
+    if (history.length === 0) {
+        return "无历史消息记录";
+    }
+    const recentMessages = history.slice(-10); // 取最近10条
+    const lines = recentMessages.map((m) => {
+        const atInfo = m.isAtBot ? " [被@]" : m.isAtAll ? " [@所有人]" : "";
+        return `${m.senderNick}${atInfo}: ${m.content}`;
+    });
+    return lines.join("\n");
+}
+// ============ Session Helpers ============
+function formatSessionShort(id) {
+    if (!id)
+        return "none";
+    return `${id.slice(0, 8)}...`;
+}
+/**
+ * 验证 session 是否在 Web 端仍然存在
+ * @param client OpenCode 客户端
+ * @param sessionId 要验证的 session ID
+ * @returns true 如果 session 存在，false 如果不存在
+ */
+async function isSessionValid(client, sessionId) {
+    try {
+        const res = await client.session.get({ path: { id: sessionId } });
+        return !!res.data;
+    }
+    catch {
+        // 如果获取失败（session 不存在），返回 false
+        return false;
+    }
+}
+/**
+ * 获取有效的 OpenCode Session
+ * 如果提供的 sessionId 在 Web 端不存在，则创建新的 session
+ * @param state 实例状态
+ * @param userId 可选的用户 ID，如果提供则返回该用户对应的 session，否则返回全局 session
+ * @param title 可选的 session 标题
+ */
+async function ensureActiveSession(state, userId, title) {
+    if (!state.client)
+        return null;
+    // 如果提供了 userId，优先使用该用户对应的 session
+    if (userId) {
+        const userSessionId = state.getUserSessionId(userId);
+        if (userSessionId) {
+            // 验证 session 是否在 Web 端仍然存在
+            const isValid = await isSessionValid(state.client, userSessionId);
+            if (isValid) {
+                return userSessionId;
+            }
+            else {
+                // session 不存在，清除本地记录，创建新的
+                logger.log(`[opencode-dingtalk] Session ${userSessionId} no longer exists in Web, creating new one`);
+                state.setUserSessionId(userId, null);
+            }
+        }
+    }
+    // 否则使用全局 session
+    if (!state.activeSessionId) {
+        try {
+            const res = await state.client.session.create({
+                body: {
+                    title: title || "钉钉机器人会话",
+                },
+            });
+            if (res.data?.id) {
+                state.activeSessionId = res.data.id;
+            }
+        }
+        catch (err) {
+            logger.error("[opencode-dingtalk] Failed to create session:", err);
+        }
+    }
+    return state.activeSessionId;
+}
+function resolvePermissionId(state, prefixOrId) {
+    if (state.pendingPermissions.has(prefixOrId))
+        return prefixOrId;
+    const normalized = prefixOrId.toLowerCase();
+    for (const id of state.pendingPermissions.keys()) {
+        if (id.toLowerCase().startsWith(normalized))
+            return id;
+    }
+    return null;
+}
+function formatTodosLine(todos) {
+    const total = todos.length;
+    const done = todos.filter((t) => t.status === "completed").length;
+    return `${done}/${total}`;
+}
+/**
+ * 格式化持续时间
+ *
+ * @param ms 毫秒数
+ * @returns 格式化的时间字符串
+ */
+function formatDuration(ms) {
+    if (ms < 1000) {
+        return `${ms}ms`;
+    }
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60) {
+        return `${seconds}s`;
+    }
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes < 60) {
+        return `${minutes}m ${remainingSeconds}s`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    if (hours < 24) {
+        return `${hours}h ${remainingMinutes}m`;
+    }
+    const days = Math.floor(hours / 24);
+    const remainingHours = hours % 24;
+    return `${days}d ${remainingHours}h`;
+}
+// ============ Outbound Retry & ACK ============
+/**
+ * 出站消息重试配置
+ */
+const OUTBOUND_RETRY_CONFIG = {
+    maxRetries: 3,
+    retryDelaysMs: [2000, 5000, 10000], // 指数退避
+    retryableErrors: [408, 429, 500, 502, 503, 504], // 可重试的 HTTP 状态码
+};
+/**
+ * 重试包装器 - 支持指数退避和可重试错误判断
+ */
+async function withRetry(fn, config, context) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastError = err;
+            // 检查是否可重试
+            const status = err.response?.status;
+            if (status && !config.retryableErrors.includes(status)) {
+                throw err; // 不可重试的错误，直接抛出
+            }
+            // 最后一次尝试，不再重试
+            if (attempt === config.maxRetries) {
+                break;
+            }
+            // 等待后重试
+            const delay = config.retryDelaysMs[attempt];
+            logger.warn(`[${context}] Retry ${attempt + 1}/${config.maxRetries} after ${delay}ms`);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+    throw lastError;
+}
+/**
+ * 记录消息确认状态
+ */
+function recordMessageAck(state, messageId, status, error) {
+    const ack = {
+        messageId,
+        timestamp: Date.now(),
+        status,
+        error,
+    };
+    state.messageAcks.set(messageId, ack);
+    // 只保留最近 100 条
+    if (state.messageAcks.size > 100) {
+        const oldest = Array.from(state.messageAcks.entries()).sort(([, a], [, b]) => a.timestamp - b.timestamp)[0];
+        if (oldest) {
+            state.messageAcks.delete(oldest[0]);
+        }
+    }
+}
+/**
+ * 从 webhook URL 中提取 userId（如果可能）
+ */
+function extractUserIdFromWebhook(webhook) {
+    // 钉钉 webhook URL 格式通常不包含 userId，返回 null
+    // 如果未来有变化，可以在这里添加解析逻辑
+    return null;
+}
+// ============ Message Sending ============
+export async function sendBySessionWebhook(webhook, text, log, messageQueue, // 可选的消息队列
+state, // 可选的实例状态（用于回退到 proactive message）
+config) {
+    const { useMarkdown, title } = detectMarkdownAndExtractTitle(text);
+    const payload = useMarkdown
+        ? {
+            msgtype: "markdown",
+            markdown: { title, text: ensureMarkdownLineBreaks(text) },
+        }
+        : { msgtype: "text", text: { content: text } };
+    // 调试日志：打印发送请求
+    const webhookShort = webhook ? `${webhook.slice(0, 30)}...` : "EMPTY";
+    logger.log(`[opencode-dingtalk][Debug] Sending message via webhook: ${webhookShort}, type=${useMarkdown ? "markdown" : "text"}, text length=${text.length}`);
+    const messageId = `webhook_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    try {
+        await withRetry(() => useMarkdown
+            ? sendMarkdownMessage(webhook, title, text)
+            : sendTextMessage(webhook, text), OUTBOUND_RETRY_CONFIG, "sendBySessionWebhook");
+        logger.log(`[opencode-dingtalk][Debug] Webhook sent successfully`);
+        log?.debug?.(`[DingTalk] Sent via session webhook, type=${useMarkdown ? "markdown" : "text"}`);
+        // 记录发送成功
+        if (state) {
+            recordMessageAck(state, messageId, "sent");
+        }
+    }
+    catch (err) {
+        logger.error(`[opencode-dingtalk][Error] Failed to send via webhook after retries: ${err.message}`, err.response?.data || "");
+        // 记录发送失败
+        if (state) {
+            recordMessageAck(state, messageId, "failed", err.message);
+        }
+        // 检查是否是 webhook 过期（4xx 错误），尝试回退到 proactive message
+        if (err.response?.status >= 400 &&
+            err.response?.status < 500 &&
+            state &&
+            config) {
+            logger.warn(`[opencode-dingtalk] Webhook may be expired (status=${err.response.status}), falling back to proactive message`);
+            // 从 webhook URL 中提取 userId（如果可能）
+            const userId = extractUserIdFromWebhook(webhook);
+            if (userId) {
+                try {
+                    await sendProactiveMessage(state, config, userId, text, log);
+                    logger.log(`[opencode-dingtalk] Fallback to proactive message succeeded for ${userId}`);
+                    return; // 成功，不抛出异常
+                }
+                catch (fallbackErr) {
+                    logger.error(`[opencode-dingtalk] Fallback to proactive message also failed: ${fallbackErr.message}`);
+                }
+            }
+        }
+        // 如果有消息队列，添加到队列以便后续重试
+        if (messageQueue) {
+            messageQueue.enqueue({
+                type: QueueType.OUTBOUND,
+                content: text,
+                target: webhook,
+                maxRetries: 3,
+                metadata: { useMarkdown, title },
+            });
+            logger.log(`[opencode-dingtalk] Message added to outbound queue for later retry`);
+        }
+        throw err;
+    }
+}
+async function sendProactiveMessage(state, config, userId, text, log) {
+    const token = await getAccessToken(state, config, log);
+    const { useMarkdown, title } = detectMarkdownAndExtractTitle(text);
+    const msgKey = useMarkdown ? "sampleMarkdown" : "sampleText";
+    const msgParam = useMarkdown
+        ? JSON.stringify({ title, text: ensureMarkdownLineBreaks(text) })
+        : JSON.stringify({ content: text });
+    const robotCode = config.robotCode || config.clientId;
+    const messageId = `proactive_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    try {
+        await withRetry(async () => {
+            const response = await fetch(`${DINGTALK_API}/v1.0/robot/oToMessages/batchSend`, {
+                method: "POST",
+                headers: {
+                    "x-acs-dingtalk-access-token": token,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    robotCode,
+                    userIds: [userId],
+                    msgKey,
+                    msgParam,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`Batch send failed: ${response.status}`);
+            }
+        }, OUTBOUND_RETRY_CONFIG, "sendProactiveMessage");
+        log?.debug?.(`[DingTalk] Sent proactive message to ${userId}, type=${msgKey}`);
+        // 记录发送成功
+        recordMessageAck(state, messageId, "sent");
+    }
+    catch (err) {
+        logger.error(`[opencode-dingtalk][Error] Failed to send proactive message to ${userId} after retries: ${err.message}`);
+        // 记录发送失败
+        recordMessageAck(state, messageId, "failed", err.message);
+        // 添加到出站队列
+        if (state.messageQueue) {
+            state.messageQueue.enqueue({
+                type: QueueType.OUTBOUND,
+                content: text,
+                target: userId,
+                maxRetries: 3,
+                metadata: { msgKey, msgParam, robotCode },
+            });
+            logger.log(`[opencode-dingtalk] Message added to outbound queue for user ${userId}`);
+        }
+        throw err;
+    }
+}
+// ============ AI Card Functions ============
+async function createAICard(state, config, targetKey, conversationId, log) {
+    try {
+        const token = await getAccessToken(state, config, log);
+        const cardInstanceId = `opencode_${Date.now()}_${randomUUID().slice(0, 8)}`;
+        const createAndDeliverBody = {
+            cardTemplateId: config.cardTemplateId || "8aebdfb9-28f4-4a98-98f5-396c3dde41a0.schema",
+            outTrackId: cardInstanceId,
+            cardData: { cardParamMap: {} },
+            callbackType: "STREAM",
+            imRobotOpenSpaceModel: { supportForward: true },
+            openSpaceId: `dtv1.card//IM_ROBOT.${conversationId}`,
+            userIdType: 1,
+            imRobotOpenDeliverModel: { spaceType: "IM_ROBOT" },
+        };
+        log?.debug?.(`[DingTalk][AICard] Creating card: ${cardInstanceId}`);
+        const response = await fetch(`${DINGTALK_API}/v1.0/card/instances/createAndDeliver`, {
+            method: "POST",
+            headers: {
+                "x-acs-dingtalk-access-token": token,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(createAndDeliverBody),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Card creation failed: ${response.status} ${errorText}`);
+        }
+        const aiCardInstance = {
+            cardInstanceId,
+            accessToken: token,
+            conversationId,
+            createdAt: Date.now(),
+            lastUpdated: Date.now(),
+            state: AICardStatus.PROCESSING,
+        };
+        state.aiCardInstances.set(cardInstanceId, aiCardInstance);
+        state.activeCardsByTarget.set(targetKey, cardInstanceId);
+        log?.debug?.(`[DingTalk][AICard] Created card: ${cardInstanceId}`);
+        return aiCardInstance;
+    }
+    catch (err) {
+        log?.error?.(`[DingTalk][AICard] Create failed: ${err.message}`);
+        return null;
+    }
+}
+async function streamAICard(state, card, content, finished = false, log) {
+    const config = state.botConfig;
+    const tokenAge = Date.now() - card.createdAt;
+    if (tokenAge > 90 * 60 * 1000 && config) {
+        try {
+            card.accessToken = await getAccessToken(state, config, log);
+        }
+        catch (err) {
+            log?.warn?.(`[DingTalk][AICard] Token refresh failed: ${err.message}`);
+        }
+    }
+    const streamBody = {
+        outTrackId: card.cardInstanceId,
+        guid: randomUUID(),
+        key: "content",
+        content,
+        isFull: true,
+        isFinalize: finished,
+        isError: false,
+    };
+    try {
+        const response = await fetch(`${DINGTALK_API}/v1.0/card/streaming`, {
+            method: "PUT",
+            headers: {
+                "x-acs-dingtalk-access-token": card.accessToken,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(streamBody),
+        });
+        if (!response.ok) {
+            throw new Error(`Card stream update failed: ${response.status}`);
+        }
+        card.lastUpdated = Date.now();
+        if (finished) {
+            card.state = AICardStatus.FINISHED;
+        }
+        else if (card.state === AICardStatus.PROCESSING) {
+            card.state = AICardStatus.INPUTING;
+        }
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        if (error.message.includes("401") && config) {
+            try {
+                card.accessToken = await getAccessToken(state, config, log);
+                const retryResponse = await fetch(`${DINGTALK_API}/v1.0/card/streaming`, {
+                    method: "PUT",
+                    headers: {
+                        "x-acs-dingtalk-access-token": card.accessToken,
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify(streamBody),
+                });
+                if (!retryResponse.ok) {
+                    throw new Error(`Card stream retry failed: ${retryResponse.status}`);
+                }
+                card.lastUpdated = Date.now();
+                if (finished)
+                    card.state = AICardStatus.FINISHED;
+                else if (card.state === AICardStatus.PROCESSING)
+                    card.state = AICardStatus.INPUTING;
+                return;
+            }
+            catch (retryErr) {
+                const retryError = retryErr instanceof Error ? retryErr : new Error(String(retryErr));
+                log?.error?.(`[DingTalk][AICard] Retry after token refresh failed: ${retryError.message}`);
+            }
+        }
+        card.state = AICardStatus.FAILED;
+        card.lastUpdated = Date.now();
+        log?.error?.(`[DingTalk][AICard] Streaming failed: ${error.message}`);
+        throw err;
+    }
+}
+async function finishAICard(state, card, content, log) {
+    await streamAICard(state, card, content, true, log);
+}
+function cleanupCardCache(state) {
+    const now = Date.now();
+    for (const [cardId, instance] of state.aiCardInstances.entries()) {
+        const isTerminal = instance.state === AICardStatus.FINISHED ||
+            instance.state === AICardStatus.FAILED;
+        if (isTerminal && now - instance.lastUpdated > CARD_CACHE_TTL) {
+            state.aiCardInstances.delete(cardId);
+            for (const [targetKey, mappedId] of state.activeCardsByTarget.entries()) {
+                if (mappedId === cardId) {
+                    state.activeCardsByTarget.delete(targetKey);
+                    break;
+                }
+            }
+        }
+    }
+}
+// ============ Card Helpers for External Use ============
+export async function streamCardToUser(state, userId, content, finished, log) {
+    const cardId = state.activeCardsByTarget.get(userId);
+    if (!cardId)
+        return false;
+    const card = state.aiCardInstances.get(cardId);
+    if (!card ||
+        card.state === AICardStatus.FINISHED ||
+        card.state === AICardStatus.FAILED) {
+        return false;
+    }
+    try {
+        if (finished) {
+            await finishAICard(state, card, content, log);
+        }
+        else {
+            await streamAICard(state, card, content, false, log);
+        }
+        return true;
+    }
+    catch (err) {
+        log?.error?.(`[DingTalk] Card stream to ${userId} failed: ${err.message}`);
+        if (finished)
+            card.state = AICardStatus.FAILED;
+        return false;
+    }
+}
+export async function streamCardToAllActive(state, content, finished, log) {
+    if (state.botConfig?.messageType !== "card")
+        return 0;
+    let count = 0;
+    for (const user of state.activeUsers.values()) {
+        const ok = await streamCardToUser(state, user.userId, content, finished, log);
+        if (ok)
+            count++;
+    }
+    return count;
+}
+// ============ Unified Send Function ============
+async function sendMessageToUser(state, userId, text, options = {}) {
+    const config = state.botConfig;
+    if (!config)
+        throw new Error("Bot not configured");
+    const { sessionWebhook, log } = options;
+    const messageType = config.messageType || "markdown";
+    if (messageType === "card") {
+        const activeCardId = state.activeCardsByTarget.get(userId);
+        if (activeCardId) {
+            const activeCard = state.aiCardInstances.get(activeCardId);
+            if (activeCard &&
+                activeCard.state !== AICardStatus.FINISHED &&
+                activeCard.state !== AICardStatus.FAILED) {
+                try {
+                    await streamAICard(state, activeCard, text, false, log);
+                    return;
+                }
+                catch (err) {
+                    log?.warn?.(`[DingTalk] AI Card streaming failed, fallback: ${err.message}`);
+                    activeCard.state = AICardStatus.FAILED;
+                }
+            }
+        }
+    }
+    if (sessionWebhook) {
+        await sendBySessionWebhook(sessionWebhook, text, log);
+    }
+    else {
+        await sendProactiveMessage(state, config, userId, text, log);
+    }
+}
+// ============ Command Handlers ============
+/**
+ * 判断 @所有人的消息是否与机器人相关
+ * 通过向大模型发送上下文，让其判断
+ */
+async function checkIfAtAllMessageIsRelevant(state, conversationId, message, log) {
+    if (!state.client)
+        return false;
+    try {
+        const context = buildGroupContext(state, conversationId);
+        const prompt = `你是钉钉群聊助手。请判断以下新消息是否与你（AI编程助手）相关。
+    
+群聊最近消息：
+${context}
+
+新消息：${message}
+
+判断标准：
+- 如果消息是针对AI的提问、请求、@或需要AI回复的，返回 "YES"
+- 如果消息是人类之间的普通聊天、与AI无关，返回 "NO"
+- 如果不确定，返回 "NO"
+
+请只回复 "YES" 或 "NO"，不要有其他内容。`;
+        // 创建一个临时会话来询问
+        const sessionId = await state.ensureGroupActiveSession(conversationId);
+        if (!sessionId)
+            return false;
+        // 直接调用 session.promptAsync 获取判断结果
+        const response = await state.client.session.promptAsync({
+            path: { id: sessionId },
+            body: {
+                parts: [{ type: "text", text: prompt }],
+            },
+        });
+        // 等待响应（这里简化处理，实际需要等待事件回调）
+        // 由于是同步判断，我们用另一种方式：直接让大模型处理
+        // 这里我们改用简单策略：如果消息包含编程相关关键词，认为相关
+        // 从配置中读取关键词，如果没有配置则使用默认关键词
+        const configKeywords = state.botConfig?.atAllKeywords || [];
+        const defaultKeywords = [
+            "代码",
+            "程序",
+            "bug",
+            "错误",
+            "修复",
+            "开发",
+            "函数",
+            "变量",
+            "class",
+            "function",
+            "import",
+            "export",
+            "def",
+            "const",
+            "let",
+            "python",
+            "javascript",
+            "java",
+            "typescript",
+            "go",
+            "rust",
+            "git",
+            "提交",
+            "分支",
+            "merge",
+            "请求",
+            "pr",
+            "cr",
+            "测试",
+            "test",
+            "单元测试",
+            "集成测试",
+            "部署",
+            "deploy",
+            "docker",
+            "k8s",
+            "kubernetes",
+            "api",
+            "接口",
+            "请求",
+            "响应",
+            "http",
+            "https",
+            "数据库",
+            "sql",
+            "mysql",
+            "redis",
+            "mongodb",
+            "linux",
+            "服务器",
+            "nginx",
+            "apache",
+            "编译",
+            "build",
+            "打包",
+            "构建",
+            "帮助",
+            "怎么",
+            "如何",
+            "为什么",
+            "?",
+        ];
+        const keywords = configKeywords.length > 0 ? configKeywords : defaultKeywords;
+        const lowerMessage = message.toLowerCase();
+        for (const keyword of keywords) {
+            if (lowerMessage.includes(keyword.toLowerCase())) {
+                return true;
+            }
+        }
+        // 默认不响应（保守策略）
+        return false;
+    }
+    catch (error) {
+        log?.error?.(`[Group] Error checking relevance: ${error}`);
+        return false;
+    }
+}
+/**
+ * 处理群聊消息
+ *
+ * 注意：根据钉钉机制，只有 @机器人 的消息才会推送给机器人
+ * 因此收到群聊消息就意味着是 @机器人 的消息，直接触发响应
+ */
+async function handleGroupMessage(state, data) {
+    const text = data.text?.content?.trim();
+    if (!text) {
+        debugLog("[Group] Empty message, ignored");
+        return;
+    }
+    // 发送者是机器人自己，跳过
+    if (data.senderId === data.chatbotUserId ||
+        data.senderStaffId === data.chatbotUserId) {
+        debugLog("[Group] Message from bot itself, ignored");
+        return;
+    }
+    const conversationId = data.conversationId;
+    const senderId = data.senderStaffId || data.senderId;
+    const senderName = data.senderNick || "Unknown";
+    const sessionWebhook = data.sessionWebhook;
+    const conversationType = data.conversationType;
+    // 调试日志：记录完整的消息上下文
+    debugLog("[Group] Received message:", {
+        conversationId,
+        conversationType,
+        senderId,
+        senderName,
+        text: text.slice(0, 100),
+        hasClient: !!state.client,
+        sessionWebhook: sessionWebhook ? "exists" : "MISSING",
+        chatbotUserId: data.chatbotUserId,
+    });
+    logger.log(`[opencode-dingtalk][Group] Message received - conversationId=${conversationId}, sessionWebhook=${sessionWebhook ? "EXISTS" : "MISSING"}`);
+    // 追踪用户，区分单聊和群聊的 sessionWebhook
+    state.trackUser(senderId, senderName, undefined, conversationId, sessionWebhook);
+    // 命令处理（群聊中以 / 开头的消息）
+    if (text.startsWith("/")) {
+        const parts = text.split(/\s+/);
+        const command = parts[0].slice(1).toLowerCase();
+        const args = parts.slice(1);
+        await handleCommand(state, command, args, senderId, sessionWebhook, {
+            conversationId: data.conversationId,
+            conversationType: "2",
+        });
+        return;
+    }
+    // 检查 OpenCode 客户端是否连接
+    if (!state.client) {
+        logger.error("[opencode-dingtalk][Group] OpenCode client not connected, cannot process message");
+        try {
+            if (sessionWebhook) {
+                await sendBySessionWebhook(sessionWebhook, "OpenCode 未连接，请确保 OpenCode 服务正常运行", logger);
+            }
+        }
+        catch { }
+        return;
+    }
+    // 根据钉钉机制：收到群聊消息 = @机器人，直接触发响应
+    await handleGroupPrompt(state, data, text, sessionWebhook);
+}
+/**
+ * 处理群聊中的 AI 提示（@机器人或相关@所有人消息）
+ */
+async function handleGroupPrompt(state, data, promptText, sessionWebhook) {
+    const conversationId = data.conversationId;
+    const senderId = data.senderStaffId || data.senderId;
+    const senderName = data.senderNick || "Unknown";
+    if (!state.client) {
+        try {
+            await sendBySessionWebhook(sessionWebhook, "OpenCode is not connected. Please wait...", logger);
+        }
+        catch { }
+        return;
+    }
+    // 获取或创建群聊会话，并保存 sessionWebhook
+    const groupSession = state.getOrCreateGroupSession(conversationId, data.title);
+    if (sessionWebhook) {
+        groupSession.sessionWebhook = sessionWebhook;
+        logger.log(`[opencode-dingtalk][Group] Saved sessionWebhook for group ${conversationId}`);
+    }
+    else {
+        logger.warn(`[opencode-dingtalk][Group] No sessionWebhook provided for group ${conversationId}!`);
+    }
+    // 调试：打印当前群会话状态
+    logger.log(`[opencode-dingtalk][Group] Group session state - conversationId: ${groupSession.conversationId}, activeSessionId: ${groupSession.activeSessionId}, sessionWebhook: ${groupSession.sessionWebhook ? "saved" : "NOT SAVED"}`);
+    // 确保有活跃的 OpenCode 会话
+    // 如果有 sessionId，验证是否在 Web 端仍然存在
+    if (groupSession.activeSessionId) {
+        const isValid = await isSessionValid(state.client, groupSession.activeSessionId);
+        if (!isValid) {
+            logger.log(`[opencode-dingtalk][Group] Session ${groupSession.activeSessionId} no longer exists in Web, creating new one`);
+            state.setGroupSessionId(conversationId, null);
+        }
+    }
+    // 重新获取 groupSession（可能已被更新）
+    const currentGroupSession = state.groupSessions.get(conversationId);
+    const currentSessionId = currentGroupSession?.activeSessionId;
+    if (!currentSessionId) {
+        // 获取群聊名称
+        const groupTitle = groupSession.title || data.title || conversationId;
+        try {
+            await sendBySessionWebhook(sessionWebhook, "正在创建会话...", logger);
+        }
+        catch { }
+        try {
+            logger.log(`[opencode-dingtalk][Group] Creating new session for group ${conversationId}...`);
+            const res = await state.client.session.create({
+                body: {
+                    title: `钉钉群聊: ${groupTitle}`,
+                },
+            });
+            if (res.data) {
+                state.setGroupSessionId(conversationId, res.data.id);
+                await state.saveGroupChatSessionMapToDisk(); // 保存群聊session映射
+                logger.log(`[opencode-dingtalk][Group] Created session: ${res.data.id}`);
+            }
+            else {
+                logger.error(`[opencode-dingtalk][Group] Failed to create session: no data in response`);
+            }
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            logger.error(`[opencode-dingtalk][Group] Failed to create session: ${errMsg}`);
+            try {
+                await sendBySessionWebhook(sessionWebhook, `创建会话失败: ${errMsg}`, logger);
+            }
+            catch { }
+            return;
+        }
+    }
+    // 重新获取 sessionId
+    const finalGroupSession = state.groupSessions.get(conversationId);
+    const sessionId = finalGroupSession?.activeSessionId;
+    if (!sessionId) {
+        return;
+    }
+    // 如果是 card 模式，创建卡片
+    const config = state.botConfig;
+    if (config?.messageType === "card") {
+        cleanupCardCache(state);
+        // 使用 conversationId 作为卡片的目标key
+        const existingCardId = state.activeCardsByTarget.get(conversationId);
+        const existingCard = existingCardId
+            ? state.aiCardInstances.get(existingCardId)
+            : undefined;
+        if (!existingCard ||
+            existingCard.state === AICardStatus.FINISHED ||
+            existingCard.state === AICardStatus.FAILED) {
+            await createAICard(state, config, conversationId, conversationId, logger);
+        }
+    }
+    // 发送提示给 OpenCode
+    try {
+        logger.log(`[opencode-dingtalk][Group] Forwarding prompt from ${senderName} to session ${sessionId}: ${promptText.slice(0, 200)}`);
+        const activeAgent = state.getActiveAgent();
+        const agentModel = activeAgent
+            ? await getAgentModel(state.client, activeAgent)
+            : null;
+        // 在群聊中，添加发送者信息作为上下文
+        const fullPrompt = `[群聊消息] 发送者: ${senderName}\n\n${promptText}`;
+        await state.client.session.promptAsync({
+            path: { id: sessionId },
+            body: {
+                ...(activeAgent ? { agent: activeAgent } : {}),
+                ...(agentModel ? { model: agentModel } : {}),
+                parts: [{ type: "text", text: fullPrompt }],
+            },
+        });
+        // 标记有待响应请求
+        state.usersWithPendingRequests.add(conversationId);
+    }
+    catch (error) {
+        const errMsg = error instanceof Error ? error.message : "Unknown error";
+        try {
+            await sendBySessionWebhook(sessionWebhook, `Error: ${errMsg}`, logger);
+        }
+        catch { }
+    }
+}
+/**
+ * 根据 userId 查找并解除 session 绑定
+ */
+function unbindSessionByUserId(state, userId) {
+    for (const [sessionId, uid] of state.sessionToUserMap.entries()) {
+        if (uid === userId) {
+            state.sessionToUserMap.delete(sessionId);
+            break;
+        }
+    }
+}
+/**
+ * 处理单聊用户创建新 Session
+ */
+async function handleNewSingleChatSession(state, userId, reply) {
+    // 清除旧 session
+    state.setUserSessionId(userId, null);
+    unbindSessionByUserId(state, userId);
+    // 获取用户名
+    const user = state.activeUsers.get(userId);
+    const userName = user?.username || userId;
+    if (!state.client) {
+        await reply("OpenCode 未连接，无法创建新会话。");
+        return;
+    }
+    try {
+        // 创建新 session
+        const res = await state.client.session.create({
+            body: {
+                title: `钉钉用户: ${userName} (${userId})`,
+            },
+        });
+        if (res.data?.id) {
+            const newSessionId = res.data.id;
+            state.setUserSessionId(userId, newSessionId);
+            state.bindSessionToUser(newSessionId, userId);
+            // 持久化
+            await state.saveSingleChatSessionMapToDisk();
+            state.saveUsersToDisk();
+            await reply(`✅ 已创建新会话: ${newSessionId.slice(0, 8)}...\n\n之前的会话已结束，现在可以开始新对话了。`);
+            logger.log(`[opencode-dingtalk] Created new session ${newSessionId} for user ${userId}`);
+        }
+        else {
+            await reply("❌ 创建新会话失败：响应中无 session ID");
+        }
+    }
+    catch (err) {
+        await reply(`❌ 创建新会话失败: ${err.message}`);
+        logger.error(`[opencode-dingtalk] Failed to create new session for user ${userId}: ${err}`);
+    }
+}
+/**
+ * 处理群聊创建新 Session
+ */
+async function handleNewGroupSession(state, conversationId, reply) {
+    // 清除旧 session
+    state.setGroupSessionId(conversationId, null);
+    // 获取群聊信息
+    const groupSession = state.groupSessions.get(conversationId);
+    const groupTitle = groupSession?.title || conversationId;
+    if (!state.client) {
+        await reply("OpenCode 未连接，无法创建新会话。");
+        return;
+    }
+    try {
+        // 创建新 session
+        const res = await state.client.session.create({
+            body: {
+                title: `钉钉群聊: ${groupTitle}`,
+            },
+        });
+        if (res.data?.id) {
+            const newSessionId = res.data.id;
+            state.setGroupSessionId(conversationId, newSessionId);
+            // 持久化
+            await state.saveGroupChatSessionMapToDisk();
+            await reply(`✅ 已创建新会话: ${newSessionId.slice(0, 8)}...\n\n之前的会话已结束，现在可以开始新对话了。`);
+            logger.log(`[opencode-dingtalk] Created new session ${newSessionId} for group ${conversationId}`);
+        }
+        else {
+            await reply("❌ 创建新会话失败：响应中无 session ID");
+        }
+    }
+    catch (err) {
+        await reply(`❌ 创建新会话失败: ${err.message}`);
+        logger.error(`[opencode-dingtalk] Failed to create new session for group ${conversationId}: ${err}`);
+    }
+}
+/**
+ * 处理 /new session 命令
+ */
+async function handleNewSession(state, senderId, conversationId, conversationType, sessionWebhook) {
+    const log = logger;
+    const reply = async (text) => {
+        try {
+            await sendMessageToUser(state, senderId, text, { sessionWebhook, log });
+        }
+        catch (err) {
+            logger.error(`[opencode-dingtalk] Failed to reply: ${err.message}`);
+        }
+    };
+    // 检查 OpenCode 客户端
+    if (!state.client) {
+        await reply("OpenCode 未连接，无法创建新会话。");
+        return;
+    }
+    // Step 1: 中断当前会话（如果正在执行）
+    try {
+        await state.client.tui.executeCommand({
+            body: { command: "session_interrupt" },
+        });
+        logger.log(`[opencode-dingtalk] Interrupted session for ${conversationType === "1" ? "user" : "group"} ${conversationId}`);
+    }
+    catch (err) {
+        // 中断失败不影响后续创建新 session
+        logger.warn(`[opencode-dingtalk] Interrupt failed: ${err}`);
+    }
+    // Step 2: 根据会话类型创建新 Session
+    if (conversationType === "1") {
+        // 单聊：重建用户 Session
+        await handleNewSingleChatSession(state, senderId, reply);
+    }
+    else if (conversationType === "2") {
+        // 群聊：重建群聊 Session
+        await handleNewGroupSession(state, conversationId, reply);
+    }
+}
+async function handleCommand(state, command, args, senderId, sessionWebhook, context) {
+    const log = logger;
+    const reply = async (text) => {
+        try {
+            await sendMessageToUser(state, senderId, text, { sessionWebhook, log });
+        }
+        catch (err) {
+            logger.error(`[opencode-dingtalk] Failed to reply: ${err.message}`);
+        }
+    };
+    switch (command) {
+        case "help": {
+            await reply([
+                "OpenCode DingTalk 命令:",
+                "- /status: 查看连接状态和会话信息",
+                "- /health: 查看系统健康状态",
+                "- /session list: 列出会话",
+                "- /session use <n|id>: 切换会话",
+                "- /session new: 创建新会话",
+                "- /new session: 为当前单聊或群聊创建新会话",
+                "- /approve <id> once|always|reject: 处理权限请求",
+                "- /answer <id> <答案>: 回答 Agent 问题",
+                "- /agent cycle: 切换 Agent",
+                "- /agent list: 列出所有可用 Agent",
+                "- /agent info: 查看当前 Agent 详情",
+                "- /interrupt: 中断当前会话",
+                "- /prompt clear: 清除提示",
+                "- /prompt submit: 提交提示",
+                "- /mute: 减少通知（仅结果+错误+权限）",
+                "- /unmute: 恢复通知",
+                "- /notify <minimal|normal|verbose>: 设置通知级别",
+                "",
+                "发送普通文本消息将作为 AI 提示发送给 OpenCode。",
+            ].join("\n"));
+            return;
+        }
+        case "status": {
+            const connected = state.client ? "Connected" : "Not connected";
+            const sessionShort = formatSessionShort(state.activeSessionId);
+            const status = state.sessionStatus
+                ? state.sessionStatus.status === "retry" && state.sessionStatus.retry
+                    ? `retry (attempt=${state.sessionStatus.retry.attempt})`
+                    : state.sessionStatus.status
+                : "unknown";
+            const todos = state.activeSessionId
+                ? state.sessionTodos.get(state.activeSessionId)
+                : undefined;
+            const todoLine = todos && todos.length > 0 ? formatTodosLine(todos) : "none";
+            const pendingPermCount = state.pendingPermissions.size;
+            const pendingQuestionsCount = state.pendingQuestions.size;
+            const activeUserCount = state.activeUsers.size;
+            const notifyLevel = state.botConfig?.notifyLevel || "normal";
+            const msgType = state.botConfig?.messageType || "markdown";
+            // 获取连接状态信息
+            let connectionState = "N/A";
+            let connectionUptime = "N/A";
+            let reconnectCount = 0;
+            let lastError = "None";
+            if (state.connectionManager) {
+                const metrics = state.connectionManager.getMetrics();
+                connectionState = state.connectionManager.getState();
+                // 计算连接时长
+                if (metrics.connectedAt) {
+                    const uptimeMs = Date.now() - metrics.connectedAt;
+                    connectionUptime = formatDuration(uptimeMs);
+                }
+                else if (metrics.totalConnectedMs > 0) {
+                    connectionUptime = formatDuration(metrics.totalConnectedMs);
+                }
+                reconnectCount = metrics.reconnectAttempts;
+                lastError = metrics.lastError || "None";
+            }
+            // 获取队列状态信息
+            let queuePending = 0;
+            let queueSending = 0;
+            let queueFailed = 0;
+            let oldestMessageAge = "N/A";
+            if (state.messageQueue) {
+                const inboundStats = state.messageQueue.getInboundStats();
+                const outboundStats = state.messageQueue.getOutboundStats();
+                queuePending = inboundStats.pending + outboundStats.pending;
+                queueSending = inboundStats.processing + outboundStats.processing;
+                queueFailed = inboundStats.failed + outboundStats.failed;
+                const oldestInbound = inboundStats.oldestPendingAge;
+                const oldestOutbound = outboundStats.oldestPendingAge;
+                const oldest = Math.max(oldestInbound, oldestOutbound);
+                if (oldest > 0) {
+                    oldestMessageAge = formatDuration(oldest);
+                }
+            }
+            // 获取会话信息
+            const activeSessions = state.groupSessions.size + (state.activeSessionId ? 1 : 0);
+            const groupSessions = state.groupSessions.size;
+            const statusLines = [
+                `📊 **系统状态**`,
+                ``,
+                `**连接状态**`,
+                `- 状态: ${connectionState}`,
+                `- 连接时长: ${connectionUptime}`,
+                `- 重连次数: ${reconnectCount}`,
+                `- 最后错误: ${lastError}`,
+                ``,
+                `**消息队列**`,
+                `- 待处理: ${queuePending}`,
+                `- 发送中: ${queueSending}`,
+                `- 失败: ${queueFailed}`,
+                `- 最老消息: ${oldestMessageAge}`,
+                ``,
+                `**会话信息**`,
+                `- 活跃用户: ${activeUserCount}`,
+                `- 活跃会话: ${activeSessions}`,
+                `- 群聊会话: ${groupSessions}`,
+                ``,
+                `**OpenCode 状态**`,
+                `- 连接: ${connected}`,
+                `- 会话: ${sessionShort}`,
+                `- 状态: ${status}`,
+                `- Todos: ${todoLine}`,
+                `- 待审批: ${pendingPermCount}`,
+            ];
+            if (pendingQuestionsCount > 0) {
+                statusLines.push(`- 待回答问题: ${pendingQuestionsCount}`);
+            }
+            statusLines.push(`- 通知: ${notifyLevel} | 消息: ${msgType}`);
+            await reply(statusLines.join("\n"));
+            return;
+        }
+        case "health": {
+            // 检查连接管理器状态
+            let isHealthy = true;
+            let healthMessage = "";
+            if (state.connectionManager) {
+                const connectionState = state.connectionManager.getState();
+                const metrics = state.connectionManager.getMetrics();
+                if (connectionState === ConnectionState.DISCONNECTED) {
+                    isHealthy = false;
+                    healthMessage = `❌ 连接已断开: ${metrics.lastError || "未知错误"}`;
+                }
+                else if (connectionState === ConnectionState.RECONNECTING) {
+                    isHealthy = false;
+                    healthMessage = `⚠️ 正在重连中 (尝试次数: ${metrics.currentReconnectCycle})`;
+                }
+                else if (connectionState === ConnectionState.CONNECTED) {
+                    healthMessage = "✅ 连接正常";
+                }
+                else {
+                    healthMessage = `⚠️ 连接状态: ${connectionState}`;
+                }
+            }
+            else {
+                // 如果没有连接管理器，检查基本连接状态
+                if (state.client) {
+                    healthMessage = "✅ OpenCode 已连接";
+                }
+                else {
+                    isHealthy = false;
+                    healthMessage = "❌ OpenCode 未连接";
+                }
+            }
+            // 检查消息队列状态
+            if (state.messageQueue) {
+                const inboundStats = state.messageQueue.getInboundStats();
+                const outboundStats = state.messageQueue.getOutboundStats();
+                const totalFailed = inboundStats.failed + outboundStats.failed;
+                if (totalFailed > 0) {
+                    isHealthy = false;
+                    healthMessage += `\n❌ 有 ${totalFailed} 条消息处理失败`;
+                }
+                const totalPending = inboundStats.pending + outboundStats.pending;
+                if (totalPending > 10) {
+                    healthMessage += `\n⚠️ 队列中有 ${totalPending} 条消息待处理`;
+                }
+            }
+            // 如果没有异常，返回正常状态
+            if (isHealthy) {
+                await reply("✅ 系统正常运行");
+            }
+            else {
+                await reply(healthMessage);
+            }
+            return;
+        }
+        case "session": {
+            const sub = args[0];
+            if (!state.client) {
+                await reply("Not connected to OpenCode.");
+                return;
+            }
+            if (sub === "list") {
+                try {
+                    const res = await state.client.session.list({});
+                    const sessions = res.data || [];
+                    if (sessions.length === 0) {
+                        await reply("No sessions.");
+                        return;
+                    }
+                    const lines = sessions.map((s, i) => {
+                        const active = s.id === state.activeSessionId;
+                        const marker = active ? "▶" : " ";
+                        const title = s.title || "(untitled)";
+                        const date = new Date(s.time.created).toLocaleString("zh-CN", {
+                            timeZone: "Asia/Shanghai",
+                            month: "2-digit",
+                            day: "2-digit",
+                            hour: "2-digit",
+                            minute: "2-digit",
+                        });
+                        const stats = s.summary
+                            ? ` +${s.summary.additions}/-${s.summary.deletions} ${s.summary.files}files`
+                            : "";
+                        return `${marker}${i + 1}. **${title}**${stats}\n   ${s.id.slice(0, 8)}... | ${date}`;
+                    });
+                    await reply(`**Sessions (${sessions.length})**\n\n${lines.join("\n")}`);
+                }
+                catch (err) {
+                    await reply(`Error: ${err.message}`);
+                }
+                return;
+            }
+            if (sub === "use") {
+                const target = args[1];
+                if (!target) {
+                    await reply("Usage: /session use <n|sessionId>");
+                    return;
+                }
+                try {
+                    const res = await state.client.session.list({});
+                    const sessions = res.data || [];
+                    if (sessions.length === 0) {
+                        await reply("No sessions available.");
+                        return;
+                    }
+                    let id;
+                    const n = Number(target);
+                    if (Number.isFinite(n)) {
+                        if (n >= 1 && n <= sessions.length) {
+                            id = sessions[n - 1]?.id;
+                        }
+                        else {
+                            await reply(`Invalid session number. Use 1-${sessions.length}.`);
+                            return;
+                        }
+                    }
+                    else {
+                        const normalized = target.toLowerCase();
+                        id = sessions.find((s) => s.id.toLowerCase() === normalized ||
+                            s.id.toLowerCase().startsWith(normalized))?.id;
+                    }
+                    if (!id) {
+                        await reply("Session not found.");
+                        return;
+                    }
+                    state.activeSessionId = id;
+                    await reply(`Switched to session ${formatSessionShort(id)}`);
+                }
+                catch (err) {
+                    await reply(`Error: ${err.message}`);
+                }
+                return;
+            }
+            if (sub === "new") {
+                try {
+                    const res = await state.client.session.create({});
+                    if (res.data?.id) {
+                        state.activeSessionId = res.data.id;
+                        await reply(`Created new session: ${formatSessionShort(res.data.id)}`);
+                    }
+                    else {
+                        await reply("Failed to create session.");
+                    }
+                }
+                catch (err) {
+                    await reply(`Error: ${err.message}`);
+                }
+                return;
+            }
+            await reply("Usage: /session list | /session use <n|id> | /session new");
+            return;
+        }
+        case "approve": {
+            const prefix = args[0];
+            const decision = args[1];
+            if (!prefix || !decision) {
+                await reply("Usage: /approve <permissionId> once|always|reject");
+                return;
+            }
+            const permissionId = resolvePermissionId(state, prefix);
+            if (!permissionId) {
+                await reply("Permission not found. Use /status to see pending permissions.");
+                return;
+            }
+            const perm = state.pendingPermissions.get(permissionId);
+            // 优先使用权限请求中记录的 sessionID，如果没有则使用当前用户的 session
+            const sessionId = perm?.sessionID || (await ensureActiveSession(state, senderId));
+            if (!state.client || !sessionId) {
+                await reply("Not connected to OpenCode.");
+                return;
+            }
+            if (decision !== "once" &&
+                decision !== "always" &&
+                decision !== "reject") {
+                await reply("Usage: /approve <permissionId> once|always|reject");
+                return;
+            }
+            try {
+                const res = await state.client.postSessionIdPermissionsPermissionId({
+                    path: { id: sessionId, permissionID: permissionId },
+                    body: { response: decision },
+                });
+                if (res.data) {
+                    state.pendingPermissions.delete(permissionId);
+                    await reply(`Approved (${decision}) for ${permissionId.slice(0, 8)}...`);
+                }
+                else {
+                    await reply("Failed to approve permission.");
+                }
+            }
+            catch (err) {
+                await reply(`Error: ${err.message}`);
+            }
+            return;
+        }
+        case "answer": {
+            const questionIdPrefix = args[0];
+            const answerArgs = args.slice(1);
+            if (!questionIdPrefix || answerArgs.length === 0) {
+                await reply("Usage: /answer <questionId> <answer1> [answer2] ...\n示例: /answer abc123 1  或  /answer abc123 1,2,3  或  /answer abc123 自定义答案");
+                return;
+            }
+            // Resolve question ID (支持前缀匹配)
+            let questionId;
+            const pending = Array.from(state.pendingQuestions.values());
+            if (pending.length === 1 && questionIdPrefix.length < 8) {
+                questionId = pending[0].id;
+            }
+            else {
+                const match = pending.find((q) => q.id.startsWith(questionIdPrefix));
+                questionId = match?.id;
+            }
+            if (!questionId) {
+                await reply("Question not found. Use /status to see pending questions.");
+                return;
+            }
+            const question = state.pendingQuestions.get(questionId);
+            if (!question) {
+                await reply("Question not found.");
+                return;
+            }
+            // 优先使用问题中记录的 sessionID，如果没有则使用当前用户的 session
+            const sessionId = question.sessionID || (await ensureActiveSession(state, senderId));
+            if (!state.client || !sessionId) {
+                await reply("Not connected to OpenCode.");
+                return;
+            }
+            try {
+                // 解析答案
+                const answers = [];
+                for (let i = 0; i < question.questions.length; i++) {
+                    const q = question.questions[i];
+                    const answerText = answerArgs[i] || "";
+                    if (!answerText) {
+                        await reply(`错误: 缺少第 ${i + 1} 个问题的答案`);
+                        return;
+                    }
+                    // 检查是否是选项序号（支持逗号分隔的多选）
+                    const parts = answerText.split(",").map((s) => s.trim());
+                    const isAllNumbers = parts.every((p) => /^\d+$/.test(p));
+                    if (isAllNumbers) {
+                        // 数字选项
+                        const selectedLabels = [];
+                        for (const numStr of parts) {
+                            const idx = parseInt(numStr, 10) - 1;
+                            if (idx < 0 || idx >= q.options.length) {
+                                await reply(`错误: 选项 ${numStr} 不存在（有效范围: 1-${q.options.length}）`);
+                                return;
+                            }
+                            selectedLabels.push(q.options[idx].label);
+                        }
+                        // 检查多选限制
+                        if (!q.multiple && selectedLabels.length > 1) {
+                            await reply(`错误: 问题 "${q.header}" 不支持多选`);
+                            return;
+                        }
+                        answers.push(selectedLabels);
+                    }
+                    else {
+                        // 自定义文本答案
+                        if (q.custom === false) {
+                            await reply(`错误: 问题 "${q.header}" 不支持自定义答案，请选择选项序号`);
+                            return;
+                        }
+                        // 如果是多个文本部分，合并为一个答案
+                        answers.push([parts.join(",")]);
+                    }
+                }
+                // 使用 HTTP 客户端直接调用 API（因为 SDK 可能版本不匹配）
+                const url = `/question/${questionId}/reply`;
+                const res = await state.client.client.post({
+                    url,
+                    body: { answers },
+                    headers: { "Content-Type": "application/json" },
+                });
+                if (res.data) {
+                    state.pendingQuestions.delete(questionId);
+                    await reply(`已回答问题 ${questionId.slice(0, 8)}...`);
+                }
+                else {
+                    await reply("Failed to answer question.");
+                }
+            }
+            catch (err) {
+                await reply(`Error: ${err.message}`);
+            }
+            return;
+        }
+        case "agent": {
+            const sub = args[0];
+            if (!state.client) {
+                await reply("Not connected to OpenCode.");
+                return;
+            }
+            if (sub === "cycle") {
+                try {
+                    const primaryAgents = await getPrimaryAgentNames(state.client);
+                    if (primaryAgents.length === 0) {
+                        await reply("No available agents.");
+                        return;
+                    }
+                    const res = await state.client.tui.executeCommand({
+                        body: { command: "agent_cycle" },
+                    });
+                    if (!res.data) {
+                        await reply("Failed to cycle agent.");
+                        return;
+                    }
+                    const next = await cycleAgentName(state, state.client, primaryAgents, state.getActiveAgent());
+                    if (!next) {
+                        await reply("Failed to cycle agent.");
+                        return;
+                    }
+                    state.setActiveAgent(next);
+                    const model = await getAgentModel(state.client, next);
+                    const modelStr = model
+                        ? `${model.providerID}/${model.modelID}`
+                        : "default";
+                    await reply(`Agent → **${next}** (${modelStr})`);
+                }
+                catch (err) {
+                    await reply(`Error: ${err.message}`);
+                }
+                return;
+            }
+            if (sub === "list") {
+                try {
+                    const res = await state.client.app.agents();
+                    const agents = (res.data ?? []).filter((a) => a.mode !== "subagent" && !a.hidden);
+                    if (agents.length === 0) {
+                        await reply("No available agents.");
+                        return;
+                    }
+                    const current = state.getActiveAgent();
+                    const lines = agents.map((a) => {
+                        const marker = a.name === current ? " ← current" : "";
+                        const model = a.model
+                            ? `${a.model.providerID}/${a.model.modelID}`
+                            : "default";
+                        return `- **${a.name}** (${model})${marker}`;
+                    });
+                    await reply(`**Agents (${agents.length})**\n\n${lines.join("\n")}`);
+                }
+                catch (err) {
+                    await reply(`Error: ${err.message}`);
+                }
+                return;
+            }
+            if (sub === "info") {
+                try {
+                    const current = state.getActiveAgent();
+                    if (!current) {
+                        await reply("No active agent. Start a session first.");
+                        return;
+                    }
+                    const res = await state.client.app.agents();
+                    const agent = (res.data ?? []).find((a) => a.name === current);
+                    if (!agent) {
+                        await reply(`Agent **${current}** not found.`);
+                        return;
+                    }
+                    const model = agent.model
+                        ? `${agent.model.providerID}/${agent.model.modelID}`
+                        : "default";
+                    const desc = agent.description || "N/A";
+                    const mode = agent.mode;
+                    const info = [
+                        `**Agent: ${agent.name}**`,
+                        "",
+                        `- **Description:** ${desc}`,
+                        `- **Model:** ${model}`,
+                        `- **Mode:** ${mode}`,
+                    ];
+                    await reply(info.join("\n"));
+                }
+                catch (err) {
+                    await reply(`Error: ${err.message}`);
+                }
+                return;
+            }
+            await reply("Usage: /agent cycle | list | info");
+            return;
+        }
+        case "interrupt": {
+            if (!state.client) {
+                await reply("Not connected to OpenCode.");
+                return;
+            }
+            try {
+                await state.client.tui.executeCommand({
+                    body: { command: "session_interrupt" },
+                });
+                await state.client.tui.executeCommand({
+                    body: { command: "session_interrupt" },
+                });
+                await reply("Session interrupted.");
+            }
+            catch (err) {
+                await reply(`Error: ${err.message}`);
+            }
+            return;
+        }
+        case "prompt": {
+            const sub = args[0];
+            if (!state.client) {
+                await reply("Not connected to OpenCode.");
+                return;
+            }
+            if (sub === "clear") {
+                try {
+                    const res = await state.client.tui.clearPrompt({});
+                    await reply(res.data ? "Prompt cleared." : "Failed to clear prompt.");
+                }
+                catch (err) {
+                    await reply(`Error: ${err.message}`);
+                }
+                return;
+            }
+            if (sub === "submit") {
+                try {
+                    const res = await state.client.tui.submitPrompt({});
+                    await reply(res.data ? "Prompt submitted." : "Failed to submit prompt.");
+                }
+                catch (err) {
+                    await reply(`Error: ${err.message}`);
+                }
+                return;
+            }
+            await reply("Usage: /prompt clear | /prompt submit");
+            return;
+        }
+        case "mute": {
+            if (!state.botConfig) {
+                await reply("Bot not configured.");
+                return;
+            }
+            state.botConfig.notifyLevel = "minimal";
+            await reply("Notifications muted (minimal). Only results, errors and permissions will be sent.\nUse /unmute to restore.");
+            return;
+        }
+        case "unmute": {
+            if (!state.botConfig) {
+                await reply("Bot not configured.");
+                return;
+            }
+            state.botConfig.notifyLevel = "normal";
+            await reply("Notifications restored (normal).");
+            return;
+        }
+        case "notify": {
+            if (!state.botConfig) {
+                await reply("Bot not configured.");
+                return;
+            }
+            const level = args[0];
+            if (level === "minimal" || level === "normal" || level === "verbose") {
+                state.botConfig.notifyLevel = level;
+                const desc = {
+                    minimal: "Only AI response, errors, permissions",
+                    normal: "Above + todo progress (debounced)",
+                    verbose: "Above + tool outputs, commands, status",
+                };
+                await reply(`Notify level: ${level}\n${desc[level]}`);
+            }
+            else {
+                await reply("Usage: /notify minimal|normal|verbose\n\nCurrent: " +
+                    (state.botConfig.notifyLevel || "normal"));
+            }
+            return;
+        }
+        case "new": {
+            const sub = args[0];
+            if (sub === "session") {
+                // 需要判断是单聊还是群聊
+                if (context?.conversationId && context?.conversationType) {
+                    await handleNewSession(state, senderId, context.conversationId, context.conversationType, sessionWebhook);
+                    return;
+                }
+                else {
+                    await reply("无法确定会话类型，请稍后重试。");
+                    return;
+                }
+            }
+            await reply("Usage: /new session");
+            return;
+        }
+        default: {
+            await reply(`Unknown command: /${command}\nUse /help to see available commands.`);
+            return;
+        }
+    }
+}
+// ============ Inbound Message Handler ============
+async function handleInboundMessage(state, data) {
+    // 忽略机器人自己发送的消息
+    if (data.senderId === data.chatbotUserId ||
+        data.senderStaffId === data.chatbotUserId) {
+        return;
+    }
+    // 结构化日志：记录入站消息
+    const messageId = data.msgId || `msg_${Date.now()}`;
+    const senderId = data.senderStaffId || data.senderId;
+    // 发送emoji确认消息，让用户知道消息已被机器人接收
+    try {
+        if (data.sessionWebhook) {
+            await sendBySessionWebhook(data.sessionWebhook, "👌", undefined, undefined, state, state.botConfig || undefined);
+            logger.log(`[opencode-dingtalk][EmojiConfirm] Sent emoji confirmation to ${senderId}`);
+        }
+    }
+    catch (err) {
+        logger.error(`[opencode-dingtalk][EmojiConfirm] Failed to send emoji confirmation: ${err.message}`);
+    }
+    logger.log(JSON.stringify({
+        type: "message",
+        event: "inbound_received",
+        timestamp: Date.now(),
+        msgId: messageId,
+        userId: senderId,
+        conversationType: data.conversationType === "1" ? "single" : "group",
+        conversationId: data.conversationId,
+    }));
+    // 如果有消息队列，将消息入队
+    if (state.messageQueue) {
+        state.messageQueue.enqueue({
+            type: QueueType.INBOUND,
+            content: JSON.stringify(data),
+            target: senderId,
+            maxRetries: 3,
+            metadata: {
+                messageId: messageId,
+                conversationType: data.conversationType,
+                conversationId: data.conversationId,
+            },
+        });
+    }
+    // 根据会话类型分别处理
+    if (data.conversationType === "1") {
+        // 单聊处理
+        await handleSingleChatMessage(state, data);
+    }
+    else if (data.conversationType === "2") {
+        // 群聊处理
+        await handleGroupMessage(state, data);
+    }
+    else {
+        logger.log(`[opencode-dingtalk] Ignoring unknown conversation type: ${data.conversationType}`);
+    }
+}
+/**
+ * 处理单聊消息 - 每个用户有独立的 session
+ */
+async function handleSingleChatMessage(state, data) {
+    const text = data.text?.content?.trim();
+    if (!text)
+        return;
+    const senderId = data.senderStaffId || data.senderId;
+    const senderName = data.senderNick || "Unknown";
+    const sessionWebhook = data.sessionWebhook;
+    // 记录用户信息，包含 sessionWebhook
+    state.trackUser(senderId, senderName, sessionWebhook, data.conversationId);
+    // 命令处理
+    if (text.startsWith("/")) {
+        const parts = text.split(/\s+/);
+        const command = parts[0].slice(1).toLowerCase();
+        const args = parts.slice(1);
+        await handleCommand(state, command, args, senderId, sessionWebhook, {
+            conversationId: data.conversationId,
+            conversationType: "1",
+        });
+        return;
+    }
+    if (!state.client) {
+        try {
+            await sendMessageToUser(state, senderId, "OpenCode is not connected. Please wait...", { sessionWebhook });
+        }
+        catch { }
+        return;
+    }
+    // 获取用户独立的 session，如不存在则创建
+    let userSessionId = state.getUserSessionId(senderId);
+    // 如果有 sessionId，验证是否在 Web 端仍然存在
+    if (userSessionId) {
+        const isValid = await isSessionValid(state.client, userSessionId);
+        if (!isValid) {
+            logger.log(`[opencode-dingtalk] Session ${userSessionId} no longer exists in Web, creating new one`);
+            userSessionId = null;
+            state.setUserSessionId(senderId, null);
+        }
+    }
+    if (!userSessionId) {
+        try {
+            await sendMessageToUser(state, senderId, "正在创建会话...", {
+                sessionWebhook,
+            });
+        }
+        catch { }
+        // Session 创建重试机制：3秒、5秒、10秒
+        const retryDelays = [3000, 5000, 10000];
+        let sessionCreated = false;
+        for (let attempt = 0; attempt < retryDelays.length; attempt++) {
+            try {
+                logger.log(`[opencode-dingtalk] Creating new session for user ${senderId} (attempt ${attempt + 1}/${retryDelays.length})...`);
+                const res = await state.client.session.create({
+                    body: {
+                        title: `钉钉用户: ${senderName} (${senderId})`,
+                    },
+                });
+                if (res.data?.id) {
+                    userSessionId = res.data.id;
+                    state.setUserSessionId(senderId, userSessionId);
+                    logger.log(`[opencode-dingtalk] Created new session ${userSessionId} for user ${senderId} (attempt ${attempt + 1})`);
+                    sessionCreated = true;
+                    break;
+                }
+                else {
+                    logger.warn(`[opencode-dingtalk] Session creation returned no data (attempt ${attempt + 1}/${retryDelays.length})`);
+                }
+            }
+            catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                logger.warn(`[opencode-dingtalk] Session creation failed (attempt ${attempt + 1}/${retryDelays.length}): ${errMsg}`);
+            }
+            // 如果不是最后一次尝试，等待后重试
+            if (attempt < retryDelays.length - 1) {
+                logger.log(`[opencode-dingtalk] Retrying in ${retryDelays[attempt]}ms...`);
+                await new Promise((resolve) => setTimeout(resolve, retryDelays[attempt]));
+            }
+        }
+        // 所有重试都失败
+        if (!sessionCreated) {
+            logger.error(`[opencode-dingtalk] Failed to create session for user ${senderId} after ${retryDelays.length} attempts`);
+            try {
+                await sendMessageToUser(state, senderId, "创建会话失败，请稍后重试", {
+                    sessionWebhook,
+                });
+            }
+            catch { }
+            return;
+        }
+    }
+    const config = state.botConfig;
+    if (config?.messageType === "card") {
+        cleanupCardCache(state);
+        // 使用 senderId 作为卡片目标key
+        const existingCardId = state.activeCardsByTarget.get(senderId);
+        const existingCard = existingCardId
+            ? state.aiCardInstances.get(existingCardId)
+            : undefined;
+        if (!existingCard ||
+            existingCard.state === AICardStatus.FINISHED ||
+            existingCard.state === AICardStatus.FAILED) {
+            await createAICard(state, config, senderId, data.conversationId, logger);
+        }
+    }
+    // 确保有有效的 sessionId
+    if (!userSessionId) {
+        logger.error(`[opencode-dingtalk] Failed to get or create session for user ${senderId}`);
+        return;
+    }
+    try {
+        logger.log(`[opencode-dingtalk] Forwarding message from ${senderName} (${senderId}) to session ${userSessionId}: ${text.slice(0, 200)}`);
+        // 绑定 sessionId 和 userId，用于响应时找到正确的用户
+        state.bindSessionToUser(userSessionId, senderId);
+        await state.saveSingleChatSessionMapToDisk(); // 保存单聊session映射
+        const activeAgent = state.getActiveAgent();
+        const agentModel = activeAgent
+            ? await getAgentModel(state.client, activeAgent)
+            : null;
+        await state.client.session.promptAsync({
+            path: { id: userSessionId },
+            body: {
+                ...(activeAgent ? { agent: activeAgent } : {}),
+                ...(agentModel ? { model: agentModel } : {}),
+                parts: [{ type: "text", text }],
+            },
+        });
+        state.usersWithPendingRequests.add(senderId);
+    }
+    catch (error) {
+        const errMsg = error instanceof Error ? error.message : "Unknown error";
+        try {
+            await sendMessageToUser(state, senderId, `Error: ${errMsg}`, {
+                sessionWebhook,
+            });
+        }
+        catch { }
+    }
+}
+// ============ Connection Watchdog ============
+const WATCHDOG_INTERVAL_MS = 15_000;
+const RECONNECT_TIMEOUT_MS = 30_000; // 30秒超时，快速响应连接中断
+const MAX_RECONNECT_PER_HOUR = 5; // 每小时最多重连 5 次
+const RECONNECT_COOLDOWN_MS = 60_000; // 重连冷却时间 60 秒
+// Stub implementation - original watchdog relied on DWClient which has been removed
+function setupConnectionWatchdog(_state, _config, _client) {
+    // No-op: watchdog not needed without DWClient
+    logger.log("[opencode-dingtalk] Watchdog: stub mode, no-op");
+}
+// ============ Bot Lifecycle ============
+export async function startBot(state, config) {
+    if (state.dwClient) {
+        throw new Error("Bot is already running");
+    }
+    if (!acquireBotLock(config.clientId)) {
+        throw new Error("Bot is already running in another process");
+    }
+    state.botConfig = config;
+    const clientId = config.clientId;
+    // 初始化消息队列
+    if (!state.messageQueue) {
+        state.messageQueue = new MessageQueue({ instanceId: clientId });
+        logger.log(`[opencode-dingtalk] MessageQueue initialized for ${clientId}`);
+    }
+    // 创建真实的 DingTalk Client
+    const client = new DingTalkClient({
+        clientId: config.clientId,
+        clientSecret: config.clientSecret,
+        debug: true, // 开启调试模式
+        subscriptions: [
+            { type: "EVENT", topic: "*" },
+            { type: "CALLBACK", topic: TOPIC_ROBOT },
+        ],
+    });
+    state.dwClient = client;
+    logger.log("[opencode-dingtalk] DingTalk bot starting with real client...");
+    // 初始化连接管理器
+    if (!state.connectionManager) {
+        state.connectionManager = new ConnectionManager(clientId);
+        // 监听连接状态变化事件
+        state.connectionManager.on("stateChange", (oldState, newState) => {
+            logger.log(JSON.stringify({
+                type: "connection",
+                event: "state_change",
+                timestamp: Date.now(),
+                oldState,
+                newState,
+            }));
+        });
+        // 监听重连成功事件
+        state.connectionManager.on("reconnectSuccess", () => {
+            logger.log(JSON.stringify({
+                type: "connection",
+                event: "reconnect_success",
+                timestamp: Date.now(),
+            }));
+        });
+        // 监听重连失败事件
+        state.connectionManager.on("reconnectFailed", (error) => {
+            logger.error(JSON.stringify({
+                type: "connection",
+                event: "reconnect_failed",
+                timestamp: Date.now(),
+                error: error.message,
+            }));
+        });
+        logger.log(`[opencode-dingtalk] ConnectionManager initialized for ${clientId}`);
+    }
+    client.registerCallbackListener(TOPIC_ROBOT, async (res) => {
+        const messageId = res.headers?.messageId;
+        try {
+            if (messageId) {
+                client.socketCallBackResponse(messageId, { success: true });
+            }
+            const data = JSON.parse(res.data);
+            const dedupKey = data.msgId || messageId;
+            if (dedupKey && isMessageProcessed(state, dedupKey)) {
+                return;
+            }
+            if (dedupKey) {
+                markMessageProcessed(state, dedupKey);
+            }
+            await handleInboundMessage(state, data);
+        }
+        catch (error) {
+            logger.error(`[opencode-dingtalk] Error processing message: ${error.message}`);
+        }
+    });
+    state.dwClient = client;
+    logger.log("[opencode-dingtalk] DingTalk bot started with real client");
+    try {
+        await client.connect();
+        logger.log("[opencode-dingtalk] DingTalk client connected successfully");
+    }
+    catch (err) {
+        logger.error("[opencode-dingtalk] Failed to connect to DingTalk:", err);
+    }
+    // 启动连接管理器
+    if (state.connectionManager) {
+        state.connectionManager.start();
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    // 启动出站队列处理器
+    setupOutboundQueueProcessor(state, config);
+}
+const OUTBOUND_QUEUE_INTERVAL = 30_000;
+function setupOutboundQueueProcessor(state, config) {
+    const timer = setInterval(async () => {
+        if (!state.messageQueue)
+            return;
+        const items = state.messageQueue.drain(QueueType.OUTBOUND, 10);
+        if (items.length === 0)
+            return;
+        logger.log(`[opencode-dingtalk] Processing ${items.length} outbound queue items`);
+        for (const item of items) {
+            try {
+                if (item.target.startsWith("http")) {
+                    await sendBySessionWebhook(item.target, item.content, logger, undefined, state, config);
+                }
+                else {
+                    await sendProactiveMessage(state, config, item.target, item.content, logger);
+                }
+                state.messageQueue.ack(item.id);
+                logger.log(`[opencode-dingtalk] Outbound queue item ${item.id} sent successfully`);
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                state.messageQueue.nack(item.id, error.message);
+                logger.error(`[opencode-dingtalk] Outbound queue item ${item.id} failed: ${error.message}`);
+            }
+        }
+    }, OUTBOUND_QUEUE_INTERVAL);
+    state.outboundQueueTimer = timer;
+    logger.log(`[opencode-dingtalk] Outbound queue processor started (interval=${OUTBOUND_QUEUE_INTERVAL}ms)`);
+}
+export async function stopBot(state) {
+    if (!state.dwClient) {
+        throw new Error("Bot is not running");
+    }
+    // Stop watchdog first so it doesn't race with cleanup
+    if (state.watchdogTimer) {
+        clearInterval(state.watchdogTimer);
+        state.watchdogTimer = null;
+    }
+    // 停止出站队列处理器
+    if (state.outboundQueueTimer) {
+        clearInterval(state.outboundQueueTimer);
+        state.outboundQueueTimer = null;
+        logger.log("[opencode-dingtalk] Outbound queue processor stopped");
+    }
+    // 停止连接管理器
+    if (state.connectionManager) {
+        state.connectionManager.stop();
+        state.connectionManager = null;
+        logger.log("[opencode-dingtalk] ConnectionManager stopped");
+    }
+    // 停止消息队列
+    if (state.messageQueue) {
+        state.messageQueue.stop();
+        state.messageQueue = null;
+        logger.log("[opencode-dingtalk] MessageQueue stopped");
+    }
+    const client = state.dwClient;
+    if (client) {
+        try {
+            client.disconnect();
+        }
+        catch (error) {
+            logger.warn(`[opencode-dingtalk] Error during disconnect: ${error instanceof Error ? error.message : error}`);
+        }
+        client.removeAllListeners();
+    }
+    releaseBotLock(state.botConfig?.clientId ?? "");
+    state.dwClient = null;
+    state.botConfig = null;
+    state.processedMessages.clear();
+    state.pendingResponses.clear();
+    state.pendingPermissions.clear();
+    state.usersWithPendingRequests.clear();
+    state.aiCardInstances.clear();
+    state.activeCardsByTarget.clear();
+    logger.log("[opencode-dingtalk] DingTalk bot stopped and cleaned up");
+}
+export async function sendToAllActive(state, message) {
+    if (!state.dwClient || !state.botConfig) {
+        throw new Error("Bot is not running");
+    }
+    const chunks = splitMessage(message, 6000);
+    let sent = 0;
+    for (const user of state.activeUsers.values()) {
+        try {
+            for (const chunk of chunks) {
+                await sendProactiveMessage(state, state.botConfig, user.userId, chunk);
+            }
+            sent++;
+        }
+        catch (error) {
+            logger.error(`[opencode-dingtalk] Failed to send to ${user.userId}:`, error);
+        }
+    }
+    return sent;
+}
+export async function sendToUser(state, userId, message) {
+    if (!state.dwClient || !state.botConfig) {
+        throw new Error("Bot is not running");
+    }
+    const chunks = splitMessage(message, 6000);
+    try {
+        for (const chunk of chunks) {
+            await sendProactiveMessage(state, state.botConfig, userId, chunk);
+        }
+        return true;
+    }
+    catch (error) {
+        logger.error(`[opencode-dingtalk] Failed to send to ${userId}:`, error);
+        return false;
+    }
+}
+/**
+ * 根据 sessionId 精确路由消息到单聊或群聊
+ * 用于权限申请、待办事项、异常等系统消息的发送
+ *
+ * @param state 实例状态
+ * @param message 消息内容
+ * @param sessionId OpenCode session ID，用于查找对应的目标
+ */
+export async function sendToSession(state, message, sessionId) {
+    if (!state.dwClient || !state.botConfig) {
+        logger.warn("[sendToSession] Bot is not running, cannot send message");
+        return;
+    }
+    // 1. 检查单聊（sessionToUserMap）
+    const userId = state.getUserIdBySession(sessionId);
+    if (userId) {
+        const user = state.activeUsers.get(userId);
+        if (user?.sessionWebhook) {
+            logger.log(`[sendToSession] 路由到单聊用户 ${userId}，使用 sessionWebhook`);
+            await sendBySessionWebhook(user.sessionWebhook, message, logger);
+            return;
+        }
+        logger.log(`[sendToSession] 路由到单聊用户 ${userId}，使用 proactiveMessage`);
+        await sendToUser(state, userId, message);
+        return;
+    }
+    // 2. 检查群聊（groupSessions）
+    for (const [convId, groupSession] of state.groupSessions) {
+        if (groupSession.activeSessionId === sessionId &&
+            groupSession.sessionWebhook) {
+            logger.log(`[sendToSession] 路由到群聊 ${convId}，使用 sessionWebhook`);
+            await sendBySessionWebhook(groupSession.sessionWebhook, message, logger);
+            return;
+        }
+    }
+    // 3. 找不到目标，记日志，不发
+    logger.warn(`[sendToSession] sessionId=${sessionId.slice(0, 8)}... 未找到对应的目标，消息不发送`);
+}