opencode-dingtalk 0.2.0

package/dist/events.js

@@ -0,0 +1,423 @@
+import { sendToAllActive, sendToUser, sendToSession, streamCardToAllActive, sendBySessionWebhook, } from "./dingtalk/bot.js";
+import { logger } from "./logger.js";
+const LEVEL_RANK = {
+    minimal: 0,
+    normal: 1,
+    verbose: 2,
+};
+function shouldNotify(state, required) {
+    const current = state.botConfig?.notifyLevel || "normal";
+    return LEVEL_RANK[current] >= LEVEL_RANK[required];
+}
+// ============ Helpers ============
+function formatTodosLine(todos) {
+    const total = todos.length;
+    const done = todos.filter((t) => t.status === "completed").length;
+    return `${done}/${total}`;
+}
+// ============ Event Handler Factory ============
+/**
+ * Creates a per-instance event handler.
+ *
+ * Timers / tracking sets that were formerly module-level globals are now
+ * local variables captured in the returned closure, ensuring isolation
+ * between multiple BotInstance objects.
+ */
+export function createEventHandler(state) {
+    // --- Per-instance closure state ---
+    const userMessageKeys = new Set();
+    const USER_MSG_KEYS_MAX = 200;
+    // --- 序列号计数器，用于确保消息排序的稳定性（当 lastUpdate 相同时） ---
+    let messageSequenceCounter = 0;
+    function trackUserMessage(sessionID, messageID) {
+        userMessageKeys.add(`${sessionID}:${messageID}`);
+        if (userMessageKeys.size > USER_MSG_KEYS_MAX) {
+            const first = userMessageKeys.values().next().value;
+            if (first)
+                userMessageKeys.delete(first);
+        }
+    }
+    function isUserMessage(sessionID, messageID) {
+        return userMessageKeys.has(`${sessionID}:${messageID}`);
+    }
+    // --- Todo debounce ---
+    const TODO_DEBOUNCE_MS = 3000;
+    let todoDebounceTimer = null;
+    let todoDebouncePayload = null;
+    let todoDebounceSessionId = null;
+    function scheduleTodoNotify(line, sessionId) {
+        todoDebouncePayload = line;
+        if (sessionId)
+            todoDebounceSessionId = sessionId;
+        if (todoDebounceTimer)
+            return;
+        todoDebounceTimer = setTimeout(async () => {
+            todoDebounceTimer = null;
+            const payload = todoDebouncePayload;
+            const sid = todoDebounceSessionId;
+            todoDebouncePayload = null;
+            todoDebounceSessionId = null;
+            if (payload && sid) {
+                try {
+                    await sendToSession(state, payload, sid);
+                }
+                catch { }
+            }
+        }, TODO_DEBOUNCE_MS);
+    }
+    function cancelTodoDebounce() {
+        if (todoDebounceTimer) {
+            clearTimeout(todoDebounceTimer);
+            todoDebounceTimer = null;
+            todoDebouncePayload = null;
+        }
+    }
+    // --- Card streaming debounce ---
+    const CARD_STREAM_INTERVAL_MS = 500;
+    let cardStreamTimer = null;
+    let cardStreamSessionId = null;
+    async function flushCardStream(sessionId, finished) {
+        if (state.botConfig?.messageType !== "card")
+            return 0;
+        let content = "";
+        for (const pending of state.pendingResponses.values()) {
+            if (pending.sessionId === sessionId && pending.textBuffer) {
+                if (content)
+                    content += "\n\n";
+                content += pending.textBuffer;
+            }
+        }
+        if (!content)
+            return 0;
+        return streamCardToAllActive(state, content, finished, console);
+    }
+    function scheduleCardStream(sessionId) {
+        if (cardStreamTimer && cardStreamSessionId === sessionId)
+            return;
+        cancelCardStreamTimer();
+        cardStreamSessionId = sessionId;
+        cardStreamTimer = setTimeout(async () => {
+            cardStreamTimer = null;
+            try {
+                await flushCardStream(sessionId, false);
+            }
+            catch (err) {
+                logger.error(`[opencode-dingtalk] Card stream flush error: ${err.message}`);
+            }
+        }, CARD_STREAM_INTERVAL_MS);
+    }
+    function cancelCardStreamTimer() {
+        if (cardStreamTimer) {
+            clearTimeout(cardStreamTimer);
+            cardStreamTimer = null;
+            cardStreamSessionId = null;
+        }
+    }
+    // ============ The Handler ============
+    return async (event) => {
+        // --- session.created ---
+        if (event.type === "session.created") {
+            const e = event;
+            if (!state.activeSessionId && e.properties?.info?.id) {
+                state.activeSessionId = e.properties.info.id;
+            }
+        }
+        // --- session.status ---
+        if (event.type === "session.status" &&
+            state.botConfig &&
+            state.activeUsers.size > 0) {
+            const e = event;
+            const status = e.properties.status;
+            state.sessionStatus = {
+                sessionID: e.properties.sessionID,
+                status: status.type === "retry" ? "retry" : status.type,
+                retry: status.type === "retry"
+                    ? {
+                        attempt: status.attempt,
+                        message: status.message,
+                        next: status.next,
+                    }
+                    : undefined,
+                updatedAt: Date.now(),
+            };
+            if (status.type === "retry") {
+                try {
+                    await sendToAllActive(state, `[重试] 尝试=${status.attempt} 下次=${Math.round(status.next / 1000)}s\n${status.message}`);
+                }
+                catch { }
+            }
+            if (status.type === "idle" && shouldNotify(state, "verbose")) {
+                try {
+                    await sendToAllActive(state, `[Status] session 空闲 (${e.properties.sessionID.slice(0, 8)}...)`);
+                }
+                catch { }
+            }
+        }
+        // --- todo.updated ---
+        if (event.type === "todo.updated" && state.botConfig) {
+            const e = event;
+            state.sessionTodos.set(e.properties.sessionID, e.properties.todos);
+            if (shouldNotify(state, "normal")) {
+                const todos = e.properties.todos;
+                if (todos.length > 0) {
+                    const inProgress = todos.find((t) => t.status === "in_progress");
+                    const line = `[Todo] ${formatTodosLine(todos)}${inProgress ? ` | in_progress: ${inProgress.content}` : ""}`;
+                    scheduleTodoNotify(line, e.properties.sessionID);
+                }
+            }
+        }
+        // --- permission.asked ---
+        if (event.type === "permission.asked" && state.botConfig) {
+            const e = event;
+            state.pendingPermissions.set(e.properties.id, {
+                id: e.properties.id,
+                sessionID: e.properties.sessionID,
+                title: e.properties.title,
+                type: e.properties.type,
+                pattern: e.properties.pattern,
+                time: e.properties.time,
+            });
+            try {
+                const id = e.properties.id;
+                await sendToSession(state, `[Permission] 请审批权限请求\n` +
+                    `id=${e.properties.id}\n` +
+                    `审批命令: /approve ${id} once|always|reject`, e.properties.sessionID);
+            }
+            catch { }
+        }
+        // --- question.asked ---
+        if (event.type === "question.asked" && state.botConfig) {
+            const e = event;
+            state.pendingQuestions.set(e.properties.id, {
+                id: e.properties.id,
+                sessionID: e.properties.sessionID,
+                questions: e.properties.questions,
+            });
+            try {
+                const id = e.properties.id;
+                const firstQ = e.properties.questions[0];
+                const optionsText = firstQ.options
+                    .map((opt, idx) => `  ${idx + 1}. ${opt.label}${opt.description ? ` - ${opt.description}` : ""}`)
+                    .join("\n");
+                let message = `[Question] Agent 正在询问问题\n` +
+                    `问题: ${firstQ.question}\n` +
+                    `选项:\n${optionsText}\n\n`;
+                if (e.properties.questions.length === 1) {
+                    if (firstQ.multiple) {
+                        message += `回答命令: /answer ${id} 1,2,3  （可多选，用逗号分隔）`;
+                    }
+                    else if (firstQ.custom !== false) {
+                        message += `回答命令: /answer ${id} <选项序号或自定义文本>`;
+                    }
+                    else {
+                        message += `回答命令: /answer ${id} <选项序号>`;
+                    }
+                }
+                else {
+                    message += `共 ${e.properties.questions.length} 个问题，回答命令: /answer ${id} <答案1> <答案2> ...`;
+                }
+                await sendToSession(state, message, e.properties.sessionID);
+            }
+            catch { }
+        }
+        // --- session.error ---
+        if (event.type === "session.error" && state.botConfig) {
+            const e = event;
+            const msg = e.properties.error?.data?.message ||
+                e.properties.error?.message ||
+                e.properties.error?.name ||
+                "Unknown error";
+            if (e.properties.sessionID) {
+                try {
+                    await sendToSession(state, `[Error] ${msg}`, e.properties.sessionID);
+                }
+                catch { }
+            }
+        }
+        // --- message.updated ---
+        if (event.type === "message.updated") {
+            const e = event;
+            const info = e.properties.info;
+            if (info?.role === "user" && info.id && info.sessionID) {
+                trackUserMessage(info.sessionID, info.id);
+                const agent = info.agent;
+                if (agent && info.sessionID) {
+                    state.setSessionAgent(info.sessionID, agent);
+                }
+            }
+            if (state.botConfig && state.activeUsers.size > 0) {
+                if (info?.role === "assistant" && info.error) {
+                    const msg = info.error.data?.message ||
+                        info.error.message ||
+                        info.error.name ||
+                        "Unknown error";
+                    try {
+                        await sendToAllActive(state, `[Assistant Error] ${msg}`);
+                    }
+                    catch { }
+                }
+            }
+        }
+        // --- message.part.updated ---
+        if (event.type === "message.part.updated" &&
+            state.botConfig &&
+            state.activeUsers.size > 0) {
+            const e = event;
+            const part = e.properties?.part;
+            if (part?.type === "text") {
+                const textPart = part;
+                if (!isUserMessage(textPart.sessionID, textPart.messageID)) {
+                    const key = `${textPart.sessionID}:${textPart.messageID}`;
+                    if (!state.pendingResponses.has(key)) {
+                        state.pendingResponses.set(key, {
+                            sessionId: textPart.sessionID,
+                            textBuffer: "",
+                            lastUpdate: Date.now(),
+                            sequence: ++messageSequenceCounter,
+                        });
+                    }
+                    const pending = state.pendingResponses.get(key);
+                    if (e.properties.delta) {
+                        pending.textBuffer += e.properties.delta;
+                    }
+                    else {
+                        pending.textBuffer = textPart.text;
+                    }
+                    pending.lastUpdate = Date.now();
+                    if (state.botConfig?.messageType === "card") {
+                        scheduleCardStream(textPart.sessionID);
+                    }
+                }
+            }
+            if (part?.type === "tool") {
+                const toolPart = part;
+                const stateType = toolPart.state?.type || toolPart.state?.status;
+                if (stateType === "error" && toolPart.state?.error) {
+                    try {
+                        await sendToSession(state, `[Tool Error: ${toolPart.tool}]\n${toolPart.state.error}`, toolPart.sessionID);
+                    }
+                    catch { }
+                }
+                if (shouldNotify(state, "verbose") &&
+                    (stateType === "completed" || stateType === "done") &&
+                    toolPart.state.output) {
+                    const output = toolPart.state.output;
+                    if (output.length > 100) {
+                        const summary = output.length > 1000 ? output.slice(0, 1000) + "..." : output;
+                        try {
+                            await sendToSession(state, `[Tool: ${toolPart.tool}]\n${summary}`, toolPart.sessionID);
+                        }
+                        catch { }
+                    }
+                }
+            }
+        }
+        // --- session.idle ---
+        if (event.type === "session.idle" &&
+            state.botConfig &&
+            state.activeUsers.size > 0) {
+            const e = event;
+            const sessionId = e.properties?.sessionID;
+            // 验证 sessionId 是否有效
+            if (!sessionId || typeof sessionId !== "string") {
+                logger.warn(`[opencode-dingtalk] session.idle event with invalid sessionId: ${sessionId}, ignoring`);
+                return;
+            }
+            cancelCardStreamTimer();
+            cancelTodoDebounce();
+            // 修复：按 lastUpdate 时间排序，确保消息按实际产生顺序发送
+            // 原因：pendingResponses Map 遍历顺序不确定，可能导致消息乱序
+            // 添加 sequence 作为辅助排序键，确保当 lastUpdate 相同时消息顺序稳定
+            const sortedPendings = Array.from(state.pendingResponses.entries())
+                .filter(([_, pending]) => pending.sessionId === sessionId && pending.textBuffer.length > 0)
+                .sort((a, b) => {
+                // 先按 lastUpdate 升序排序
+                const timeDiff = a[1].lastUpdate - b[1].lastUpdate;
+                if (timeDiff !== 0)
+                    return timeDiff;
+                // 当 lastUpdate 相同时，按 sequence 升序排序（消息产生顺序）
+                return a[1].sequence - b[1].sequence;
+            });
+            for (const [key, pending] of sortedPendings) {
+                if (!state.processedMessages.has(key)) {
+                    state.processedMessages.add(key);
+                    const text = pending.textBuffer;
+                    if (text.length > 0) {
+                        try {
+                            const message = text.length > 6000
+                                ? text.slice(0, 6000) + "\n\n[Truncated...]"
+                                : text;
+                            let sentViaCard = false;
+                            if (state.botConfig?.messageType === "card") {
+                                const count = await flushCardStream(sessionId, true);
+                                sentViaCard = count > 0;
+                            }
+                            if (!sentViaCard) {
+                                // 检查是否是单聊（sessionId 在 sessionToUserMap 中）
+                                const userId = state.getUserIdBySession(sessionId);
+                                if (userId) {
+                                    // 单聊响应
+                                    const user = state.activeUsers.get(userId);
+                                    if (user?.sessionWebhook) {
+                                        logger.log(`[opencode-dingtalk][Single] Sending to user ${userId} via sessionWebhook`);
+                                        await sendBySessionWebhook(user.sessionWebhook, message, console);
+                                        logger.log(`[opencode-dingtalk][Single] Sent response to user ${userId}`);
+                                    }
+                                    else {
+                                        logger.log(`[opencode-dingtalk][Single] No sessionWebhook for user ${userId}, sending proactive message`);
+                                        await sendToUser(state, userId, message);
+                                        logger.log(`[opencode-dingtalk][Single] Sent proactive message to user ${userId}`);
+                                    }
+                                }
+                                else {
+                                    // 检查是否是群聊（sessionId 在 groupSessions 中）
+                                    let sentToGroup = false;
+                                    for (const [groupKey, groupSession] of state.groupSessions) {
+                                        if (groupSession.activeSessionId === sessionId &&
+                                            groupSession.sessionWebhook) {
+                                            logger.log(`[opencode-dingtalk][Group] Sending to group ${groupSession.conversationId}`);
+                                            await sendBySessionWebhook(groupSession.sessionWebhook, message, console);
+                                            sentToGroup = true;
+                                            logger.log(`[opencode-dingtalk][Group] Sent response to group ${groupSession.conversationId}`);
+                                            break;
+                                        }
+                                    }
+                                    if (!sentToGroup) {
+                                        // sessionId 既不在 sessionToUserMap 也不在 groupSessions 中
+                                        logger.error(`[opencode-dingtalk][Error] Cannot route response for sessionId=${sessionId}: not found in sessionToUserMap or groupSessions`);
+                                    }
+                                }
+                                // 发送后延迟 100ms，确保钉钉服务器按顺序处理消息
+                                // 修复：消息顺序错乱问题 - 异步 HTTP 发送无顺序保证
+                                await new Promise((resolve) => setTimeout(resolve, 100));
+                            }
+                        }
+                        catch (err) {
+                            logger.error(`[opencode-dingtalk] Failed to send response: ${err.message}`, err);
+                        }
+                    }
+                    state.pendingResponses.delete(key);
+                }
+            }
+            // 不再清理 session 到 user 的映射，单聊和群聊一样长期保留
+            // 这样权限申请、待办事项、异常等系统消息才能正确路由到对应的目标
+            state.usersWithPendingRequests.clear();
+            if (state.processedMessages.size > 100) {
+                const arr = Array.from(state.processedMessages);
+                arr.slice(0, 50).forEach((k) => state.processedMessages.delete(k));
+            }
+        }
+        // --- command.executed ---
+        if (event.type === "command.executed" &&
+            state.botConfig &&
+            state.activeUsers.size > 0) {
+            if (shouldNotify(state, "verbose")) {
+                const e = event;
+                try {
+                    await sendToAllActive(state, `[Command] ${e.properties.name} ${e.properties.arguments}`);
+                }
+                catch { }
+            }
+        }
+    };
+}

package/dist/index.js

@@ -0,0 +1,164 @@
+// Silence all console output by default so plugin logs don't appear in the
+// opencode UI. Remove or comment out these lines to enable debug logging.
+console.log =
+    console.info =
+        console.warn =
+            console.error =
+                console.debug =
+                    () => { };
+import { tool } from "@opencode-ai/plugin/tool";
+import { z } from "zod/v4";
+import { resolveConfig, resolveInstances, } from "./config.js";
+import { getOrCreateInstance, shutdownAll } from "./registry.js";
+import { logger } from "./logger.js";
+// ============ Helpers ============
+function findConfigByName(name) {
+    const all = resolveInstances();
+    const lower = name.toLowerCase();
+    return all.find((c) => c.name?.toLowerCase() === lower || c.clientId?.toLowerCase() === lower);
+}
+function buildBotConfig(cfg) {
+    return {
+        clientId: cfg.clientId,
+        clientSecret: cfg.clientSecret,
+        robotCode: cfg.robotCode,
+        messageType: cfg.messageType,
+        cardTemplateId: cfg.cardTemplateId,
+        notifyLevel: cfg.notifyLevel,
+    };
+}
+// ============ Plugin Definition ============
+export const OpenCodeDingtalkPlugin = async ({ client, serverUrl }) => {
+    // 添加详细调试日志
+    logger.log("[opencode-dingtalk][DEBUG] === Plugin starting ===");
+    logger.log("[opencode-dingtalk][DEBUG] client:", client ? "exists" : "null");
+    logger.log("[opencode-dingtalk][DEBUG] serverUrl:", serverUrl?.toString() || "undefined");
+    const config = resolveConfig();
+    logger.log("[opencode-dingtalk][DEBUG] resolveConfig() returned:", JSON.stringify({
+        clientId: config.clientId ? "***" : undefined,
+        clientSecret: config.clientSecret ? "***" : undefined,
+        robotCode: config.robotCode,
+        autoStart: config.autoStart,
+        messageType: config.messageType,
+        opencodeUrl: config.opencodeUrl,
+    }));
+    const instanceId = config.clientId || "default";
+    logger.log("[opencode-dingtalk][DEBUG] instanceId:", instanceId);
+    const hasCreds = !!(config.clientId && config.clientSecret);
+    logger.log("[opencode-dingtalk][DEBUG] hasCreds:", hasCreds);
+    const instance = getOrCreateInstance({
+        instanceId,
+        client,
+        serverUrl: serverUrl?.toString(),
+        ...(hasCreds ? { botConfig: buildBotConfig(config) } : {}),
+    });
+    logger.log("[opencode-dingtalk][DEBUG] After getOrCreateInstance:");
+    logger.log("[opencode-dingtalk][DEBUG] - options passed:", JSON.stringify({
+        instanceId,
+        hasClient: !!client,
+        hasServerUrl: !!serverUrl,
+        hasBotConfig: hasCreds,
+    }));
+    logger.log("[opencode-dingtalk][DEBUG] - instance.isRunning:", instance.isRunning);
+    logger.log("[opencode-dingtalk][DEBUG] - instance.state.botConfig:", instance.state.botConfig ? "exists" : "null");
+    if (instance.state.botConfig) {
+        logger.log("[opencode-dingtalk][DEBUG] - botConfig.clientId:", instance.state.botConfig.clientId);
+        logger.log("[opencode-dingtalk][DEBUG] - botConfig.robotCode:", instance.state.botConfig.robotCode);
+    }
+    // 检查实际的连接状态
+    if (instance.state.connectionManager) {
+        const connState = instance.state.connectionManager.getState();
+        const metrics = instance.state.connectionManager.getMetrics();
+        logger.log("[opencode-dingtalk][DEBUG] ConnectionManager state:", connState);
+        logger.log("[opencode-dingtalk][DEBUG] ConnectionManager metrics:", JSON.stringify({
+            connectedAt: metrics.connectedAt,
+            totalConnectedMs: metrics.totalConnectedMs,
+            reconnectAttempts: metrics.reconnectAttempts,
+            lastError: metrics.lastError,
+        }));
+    }
+    else {
+        logger.log("[opencode-dingtalk][DEBUG] No ConnectionManager initialized yet");
+    }
+    // Auto-start bot if configured
+    logger.log("[opencode-dingtalk][DEBUG] Checking auto-start conditions:", {
+        configAutoStart: config.autoStart,
+        hasCreds: hasCreds,
+        isRunning: instance.isRunning,
+        shouldStart: config.autoStart && hasCreds && !instance.isRunning,
+    });
+    if (config.autoStart && hasCreds && !instance.isRunning) {
+        logger.log("[opencode-dingtalk][DEBUG] === Starting bot ===");
+        try {
+            logger.log("[opencode-dingtalk][DEBUG] Calling instance.startWithConfig()...");
+            await instance.startWithConfig(buildBotConfig(config));
+            logger.log("[opencode-dingtalk][DEBUG] startWithConfig() completed");
+            logger.log(`[opencode-dingtalk] Auto-started bot (mode: ${config.messageType})`);
+            if (instance.state.activeUsers.size > 0) {
+                await instance
+                    .sendToAllActive("机器人已连接，可以开始使用了")
+                    .catch(() => { });
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.log("[opencode-dingtalk][DEBUG] Error during start:", msg);
+            if (msg.includes("another process")) {
+                logger.log("[opencode-dingtalk] Bot already running in another process, skipping auto-start");
+            }
+            else {
+                logger.error("[opencode-dingtalk] Auto-start failed:", err);
+            }
+        }
+    }
+    else {
+        logger.log("[opencode-dingtalk][DEBUG] === NOT starting bot, conditions not met ===");
+        if (!config.autoStart)
+            logger.log("[opencode-dingtalk][DEBUG] Reason: autoStart is false");
+        if (!hasCreds)
+            logger.log("[opencode-dingtalk][DEBUG] Reason: missing credentials");
+        if (instance.isRunning)
+            logger.log("[opencode-dingtalk][DEBUG] Reason: already running");
+    }
+    logger.log("[opencode-dingtalk][DEBUG] === Plugin initialization complete, returning handlers ===");
+    return {
+        event: async ({ event }) => {
+            const evt = event;
+            await instance.handleEvent(evt);
+        },
+        tool: {
+            "opencode-dingtalk-send": tool({
+                description: "向指定用户发送消息",
+                args: {
+                    userId: z.string().describe("用户工号"),
+                    message: z.string().describe("要发送的消息内容"),
+                },
+                async execute({ userId, message }) {
+                    try {
+                        const success = await instance.sendToUser(userId, message);
+                        if (success) {
+                            return `消息已成功发送给用户 ${userId}`;
+                        }
+                        else {
+                            return `发送失败，请检查用户工号是否正确或机器人是否正常运行`;
+                        }
+                    }
+                    catch (error) {
+                        return `Error: ${error instanceof Error ? error.message : "Unknown error"}`;
+                    }
+                },
+            }),
+        },
+    };
+};
+export default OpenCodeDingtalkPlugin;
+// Ensure all instances are stopped when the host process exits
+async function shutdown() {
+    try {
+        await shutdownAll();
+    }
+    catch { }
+    process.exit(0);
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);

package/dist/index.test.js

@@ -0,0 +1,6 @@
+import { OpenCodeDingtalkPlugin } from "./index.js";
+describe("OpenCodeDingtalkPlugin", () => {
+    it("should export a plugin function", () => {
+        expect(typeof OpenCodeDingtalkPlugin).toBe("function");
+    });
+});

package/dist/instance.js

@@ -0,0 +1,49 @@
+import { InstanceState } from "./state.js";
+import { startBot, stopBot, sendToAllActive, sendToUser } from "./dingtalk/bot.js";
+import { createEventHandler } from "./events.js";
+export class BotInstance {
+    state;
+    eventHandler;
+    constructor(options) {
+        this.state = new InstanceState(options.instanceId);
+        if (options.client)
+            this.state.client = options.client;
+        if (options.serverUrl)
+            this.state.serverUrl = options.serverUrl;
+        if (options.botConfig)
+            this.state.botConfig = options.botConfig;
+        this.eventHandler = createEventHandler(this.state);
+    }
+    get instanceId() {
+        return this.state.instanceId;
+    }
+    get isRunning() {
+        return this.state.botConfig !== null && this.state.connectionManager !== null;
+    }
+    /** Start the DingTalk Stream connection using state.botConfig. */
+    async start() {
+        if (!this.state.botConfig)
+            throw new Error(`[${this.instanceId}] Bot not configured`);
+        await startBot(this.state, this.state.botConfig);
+    }
+    /** Start with an explicit config (sets state.botConfig first). */
+    async startWithConfig(config) {
+        await startBot(this.state, config);
+    }
+    /** Disconnect from DingTalk and clean up. */
+    async stop() {
+        await stopBot(this.state);
+    }
+    /** Dispatch an OpenCode event to this instance's handler. */
+    async handleEvent(event) {
+        await this.eventHandler(event);
+    }
+    /** Send a message to all active users of this instance. */
+    async sendToAllActive(message) {
+        return sendToAllActive(this.state, message);
+    }
+    /** Send a message to a specific user. */
+    async sendToUser(userId, message) {
+        return sendToUser(this.state, userId, message);
+    }
+}