opencode-dingtalk 0.2.0

package/dist/state.js

@@ -0,0 +1,550 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getDataDir } from "./utils.js";
+export const AICardStatus = {
+    PROCESSING: "processing",
+    INPUTING: "inputing",
+    FINISHED: "finished",
+    FAILED: "failed",
+};
+/**
+ * Per-instance state. Each BotInstance holds its own InstanceState,
+ * ensuring complete isolation between multiple DingTalk bots.
+ */
+export class InstanceState {
+    instanceId;
+    dwClient = null;
+    botConfig = null;
+    watchdogTimer = null;
+    client = null;
+    serverUrl = null;
+    activeUsers = new Map();
+    accessToken = null;
+    accessTokenExpiry = 0;
+    activeSessionId = null;
+    // 群聊相关状态
+    groupSessions = new Map();
+    /** 群聊消息历史记录的最大条数 */
+    GROUP_HISTORY_MAX = 20;
+    pendingResponses = new Map();
+    processedMessages = new Set();
+    pendingPermissions = new Map();
+    /** Users who sent a message that hasn't received an AI reply yet */
+    usersWithPendingRequests = new Set();
+    pendingQuestions = new Map();
+    sessionStatus = null;
+    sessionTodos = new Map();
+    sessionAgents = new Map();
+    aiCardInstances = new Map();
+    activeCardsByTarget = new Map();
+    /** sessionId -> userId 映射，用于响应时找到正确的用户 */
+    sessionToUserMap = new Map();
+    /** Message dedup map (moved from bot.ts module-level) */
+    processedInbound = new Map();
+    /** 连接管理器 */
+    connectionManager = null;
+    /** 消息队列 */
+    messageQueue = null;
+    /** 出站队列定时器 */
+    outboundQueueTimer = null;
+    /** 消息确认记录 */
+    messageAcks = new Map();
+    constructor(instanceId) {
+        this.instanceId = instanceId;
+        this.loadUsersFromDisk();
+        this.loadGroupSessionsFromDisk();
+        this.loadAllSessionMapsFromDisk(); // 加载session映射（单聊+群聊）
+    }
+    // ============ Persistence ============
+    getUsersPersistPath() {
+        return path.join(getDataDir(), `active-users-${this.instanceId}.json`);
+    }
+    /**
+     * 获取群聊 session 持久化文件路径
+     */
+    getGroupSessionsPersistPath() {
+        return path.join(getDataDir(), `group-sessions-${this.instanceId}.json`);
+    }
+    loadUsersFromDisk() {
+        const filePath = this.getUsersPersistPath();
+        try {
+            const raw = fs.readFileSync(filePath, "utf8");
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed.users)) {
+                this.activeUsers.clear();
+                for (const u of parsed.users) {
+                    if (!u || typeof u.userId !== "string")
+                        continue;
+                    this.activeUsers.set(u.userId, {
+                        userId: u.userId,
+                        username: typeof u.username === "string" ? u.username : undefined,
+                        firstSeenAt: typeof u.firstSeenAt === "number" ? u.firstSeenAt : Date.now(),
+                        lastActiveAt: typeof u.lastActiveAt === "number" ? u.lastActiveAt : Date.now(),
+                        sessionId: typeof u.sessionId === "string" ? u.sessionId : null,
+                        sessionWebhook: typeof u.sessionWebhook === "string" ? u.sessionWebhook : undefined,
+                    });
+                }
+            }
+        }
+        catch {
+            return;
+        }
+    }
+    /**
+     * 从磁盘加载群聊 session
+     */
+    loadGroupSessionsFromDisk() {
+        const filePath = this.getGroupSessionsPersistPath();
+        try {
+            const raw = fs.readFileSync(filePath, "utf8");
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed.groupSessions)) {
+                for (const gs of parsed.groupSessions) {
+                    if (!gs || typeof gs.conversationId !== "string")
+                        continue;
+                    this.groupSessions.set(gs.conversationId, {
+                        conversationId: gs.conversationId,
+                        title: typeof gs.title === "string" ? gs.title : undefined,
+                        activeSessionId: typeof gs.activeSessionId === "string" ? gs.activeSessionId : null,
+                        sessionWebhook: undefined,
+                        createdAt: typeof gs.createdAt === "number" ? gs.createdAt : Date.now(),
+                        lastActiveAt: typeof gs.lastActiveAt === "number" ? gs.lastActiveAt : Date.now(),
+                        messageHistory: [],
+                    });
+                }
+            }
+        }
+        catch {
+            return;
+        }
+    }
+    saveUsersToDisk() {
+        const filePath = this.getUsersPersistPath();
+        try {
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        }
+        catch {
+            return;
+        }
+        const users = Array.from(this.activeUsers.values());
+        try {
+            fs.writeFileSync(filePath, JSON.stringify({ users }, null, 2) + "\n", "utf8");
+        }
+        catch {
+            return;
+        }
+    }
+    /**
+     * 保存群聊 session 到磁盘
+     */
+    saveGroupSessionsToDisk() {
+        const filePath = this.getGroupSessionsPersistPath();
+        try {
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        }
+        catch {
+            return;
+        }
+        const groupSessions = Array.from(this.groupSessions.values()).map(gs => ({
+            conversationId: gs.conversationId,
+            title: gs.title,
+            activeSessionId: gs.activeSessionId,
+            createdAt: gs.createdAt,
+            lastActiveAt: gs.lastActiveAt,
+        }));
+        try {
+            fs.writeFileSync(filePath, JSON.stringify({ groupSessions }, null, 2) + "\n", "utf8");
+        }
+        catch {
+            return;
+        }
+    }
+    // ============ Session Map Persistence ============
+    /**
+     * 获取session映射持久化文件路径
+     */
+    getSessionMapPersistPath() {
+        return path.join(getDataDir(), `session-map-${this.instanceId}.json`);
+    }
+    /**
+     * 获取文件锁路径
+     */
+    getLockFilePath() {
+        return path.join(getDataDir(), `session-map-${this.instanceId}.lock`);
+    }
+    /**
+     * 获取文件锁
+     * @param timeoutMs 锁超时时间（毫秒），默认 5000ms
+     * @returns 文件描述符，失败返回 null
+     */
+    async acquireLock(timeoutMs = 5000) {
+        const lockPath = this.getLockFilePath();
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeoutMs) {
+            try {
+                // 尝试创建锁文件（独占模式）
+                const fd = fs.openSync(lockPath, 'wx');
+                // 写入进程ID和时间戳
+                fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+                return fd;
+            }
+            catch (err) {
+                if (err.code === 'EEXIST') {
+                    // 锁文件已存在，检查是否过期（超过30秒视为过期）
+                    try {
+                        const lockData = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+                        if (Date.now() - lockData.timestamp > 30000) {
+                            // 锁已过期，删除并重试
+                            fs.unlinkSync(lockPath);
+                            continue;
+                        }
+                    }
+                    catch {
+                        // 锁文件损坏，删除并重试
+                        try {
+                            fs.unlinkSync(lockPath);
+                        }
+                        catch { }
+                        continue;
+                    }
+                    // 等待100ms后重试
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                }
+                else {
+                    // 其他错误，返回 null
+                    return null;
+                }
+            }
+        }
+        return null; // 超时
+    }
+    /**
+     * 释放文件锁
+     * @param fd 文件描述符
+     */
+    releaseLock(fd) {
+        if (fd === null)
+            return;
+        try {
+            fs.closeSync(fd);
+            fs.unlinkSync(this.getLockFilePath());
+        }
+        catch {
+            // 忽略释放锁时的错误
+        }
+    }
+    /**
+     * 保存单聊session映射到磁盘
+     * 使用全局锁避免并发写入
+     */
+    async saveSingleChatSessionMapToDisk() {
+        const fd = await this.acquireLock();
+        if (fd === null) {
+            return;
+        }
+        try {
+            const filePath = this.getSessionMapPersistPath();
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+            // 读取现有数据（如果存在）
+            let existingData = {};
+            try {
+                const raw = fs.readFileSync(filePath, 'utf8');
+                existingData = JSON.parse(raw);
+            }
+            catch {
+                // 文件不存在或解析失败，使用空对象
+            }
+            // 更新单聊部分
+            existingData.singleChatSessions = {
+                user_session_map: Array.from(this.sessionToUserMap.entries()),
+                lastUpdated: Date.now(),
+            };
+            // 保留群聊部分（如果存在）
+            if (!existingData.groupChatSessions) {
+                existingData.groupChatSessions = {
+                    conversation_session_map: [],
+                    lastUpdated: Date.now(),
+                };
+            }
+            fs.writeFileSync(filePath, JSON.stringify(existingData, null, 2) + "\n", "utf8");
+        }
+        catch (err) {
+            // 忽略保存错误
+        }
+        finally {
+            this.releaseLock(fd);
+        }
+    }
+    /**
+     * 保存群聊session映射到磁盘
+     * 使用全局锁避免并发写入
+     */
+    async saveGroupChatSessionMapToDisk() {
+        const fd = await this.acquireLock();
+        if (fd === null) {
+            return;
+        }
+        try {
+            const filePath = this.getSessionMapPersistPath();
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+            // 读取现有数据（如果存在）
+            let existingData = {};
+            try {
+                const raw = fs.readFileSync(filePath, 'utf8');
+                existingData = JSON.parse(raw);
+            }
+            catch {
+                // 文件不存在或解析失败，使用空对象
+            }
+            // 更新群聊部分
+            existingData.groupChatSessions = {
+                conversation_session_map: Array.from(this.groupSessions.entries()).map(([convId, session]) => [convId, session.activeSessionId]),
+                lastUpdated: Date.now(),
+            };
+            // 保留单聊部分（如果存在）
+            if (!existingData.singleChatSessions) {
+                existingData.singleChatSessions = {
+                    user_session_map: [],
+                    lastUpdated: Date.now(),
+                };
+            }
+            fs.writeFileSync(filePath, JSON.stringify(existingData, null, 2) + "\n", "utf8");
+        }
+        catch (err) {
+            // 忽略保存错误
+        }
+        finally {
+            this.releaseLock(fd);
+        }
+    }
+    /**
+     * 从磁盘加载所有session映射（单聊 + 群聊）
+     * 启动时调用，无需加锁（单线程启动）
+     */
+    loadAllSessionMapsFromDisk() {
+        const filePath = this.getSessionMapPersistPath();
+        try {
+            const raw = fs.readFileSync(filePath, 'utf8');
+            const parsed = JSON.parse(raw);
+            // 加载单聊映射
+            if (parsed.singleChatSessions) {
+                if (Array.isArray(parsed.singleChatSessions.user_session_map)) {
+                    this.sessionToUserMap = new Map(parsed.singleChatSessions.user_session_map);
+                }
+            }
+            // 群聊的 activeSessionId 已经在 loadGroupSessionsFromDisk 中加载
+            // 这里无需重复加载
+        }
+        catch {
+            // 文件不存在或解析失败，忽略
+        }
+    }
+    // ============ User Tracking ============
+    /**
+     * 记录用户信息
+     * @param userId 用户ID
+     * @param username 用户名
+     * @param sessionWebhook 单聊的 session webhook
+     * @param conversationId 群聊会话ID（如果是群聊则传入）
+     * @param groupWebhook 群聊的 session webhook（如果是群聊则传入）
+     */
+    trackUser(userId, username, sessionWebhook, conversationId, groupWebhook) {
+        const existing = this.activeUsers.get(userId);
+        if (existing) {
+            existing.lastActiveAt = Date.now();
+            if (username)
+                existing.username = username;
+            // 单聊的 webhook
+            if (sessionWebhook)
+                existing.sessionWebhook = sessionWebhook;
+            // 群聊的 webhook 需要单独存储，避免覆盖单聊的 webhook
+            if (conversationId && groupWebhook) {
+                if (!existing.groupSessionWebhooks) {
+                    existing.groupSessionWebhooks = new Map();
+                }
+                existing.groupSessionWebhooks.set(conversationId, groupWebhook);
+            }
+        }
+        else {
+            const newUser = {
+                userId,
+                username,
+                firstSeenAt: Date.now(),
+                lastActiveAt: Date.now(),
+                sessionId: null,
+                sessionWebhook,
+            };
+            // 群聊的 webhook
+            if (conversationId && groupWebhook) {
+                newUser.groupSessionWebhooks = new Map();
+                newUser.groupSessionWebhooks.set(conversationId, groupWebhook);
+            }
+            this.activeUsers.set(userId, newUser);
+        }
+        this.saveUsersToDisk();
+    }
+    /**
+     * 获取用户在指定群聊中的 session webhook
+     */
+    getGroupSessionWebhook(userId, conversationId) {
+        const user = this.activeUsers.get(userId);
+        return user?.groupSessionWebhooks?.get(conversationId);
+    }
+    /**
+     * 获取用户的 OpenCode 会话 ID，如不存在则返回 null
+     */
+    getUserSessionId(userId) {
+        const user = this.activeUsers.get(userId);
+        return user?.sessionId;
+    }
+    /**
+     * 设置用户的 OpenCode 会话 ID
+     */
+    setUserSessionId(userId, sessionId) {
+        const user = this.activeUsers.get(userId);
+        if (user) {
+            user.sessionId = sessionId;
+        }
+    }
+    /**
+     * 获取用户消息历史的 key（用于 pendingResponses）
+     */
+    getUserResponseKey(userId, sessionId) {
+        return `user:${userId}:${sessionId}`;
+    }
+    /**
+     * 关联 sessionId 和 userId
+     */
+    bindSessionToUser(sessionId, userId) {
+        this.sessionToUserMap.set(sessionId, userId);
+    }
+    /**
+     * 根据 sessionId 获取 userId
+     */
+    getUserIdBySession(sessionId) {
+        return this.sessionToUserMap.get(sessionId);
+    }
+    /**
+     * 清理 session 到 user 的映射
+     */
+    unbindSession(sessionId) {
+        this.sessionToUserMap.delete(sessionId);
+    }
+    getActiveUsers() {
+        return Array.from(this.activeUsers.values());
+    }
+    isUserActive(userId) {
+        return this.activeUsers.has(userId);
+    }
+    // ============ Session Agent ============
+    setSessionAgent(sessionId, agent) {
+        this.sessionAgents.set(sessionId, agent);
+    }
+    getActiveAgent() {
+        if (!this.activeSessionId)
+            return null;
+        return this.sessionAgents.get(this.activeSessionId) ?? null;
+    }
+    setActiveAgent(agent) {
+        if (this.activeSessionId) {
+            this.sessionAgents.set(this.activeSessionId, agent);
+        }
+    }
+    // ============ Group Session Management ============
+    /**
+     * 获取或创建群聊会话
+     */
+    getOrCreateGroupSession(conversationId, title) {
+        let session = this.groupSessions.get(conversationId);
+        if (!session) {
+            session = {
+                conversationId,
+                title,
+                activeSessionId: null,
+                createdAt: Date.now(),
+                lastActiveAt: Date.now(),
+                messageHistory: [],
+            };
+            this.groupSessions.set(conversationId, session);
+        }
+        else {
+            session.lastActiveAt = Date.now();
+            if (title)
+                session.title = title;
+        }
+        // 保存到磁盘
+        this.saveGroupSessionsToDisk();
+        return session;
+    }
+    /**
+     * 更新群聊的 activeSessionId 并持久化
+     */
+    setGroupSessionId(conversationId, sessionId) {
+        const session = this.groupSessions.get(conversationId);
+        if (session) {
+            session.activeSessionId = sessionId;
+            this.saveGroupSessionsToDisk();
+        }
+    }
+    /**
+     * 添加群聊消息到历史记录
+     */
+    addGroupMessage(conversationId, message) {
+        const session = this.groupSessions.get(conversationId);
+        if (!session)
+            return;
+        const newMessage = {
+            id: `msg_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            timestamp: Date.now(),
+            ...message,
+        };
+        session.messageHistory.push(newMessage);
+        // 限制历史记录数量
+        if (session.messageHistory.length > this.GROUP_HISTORY_MAX) {
+            session.messageHistory = session.messageHistory.slice(-this.GROUP_HISTORY_MAX);
+        }
+    }
+    /**
+     * 获取群聊消息历史（用于大模型判断相关性）
+     */
+    getGroupMessageHistory(conversationId) {
+        const session = this.groupSessions.get(conversationId);
+        return session?.messageHistory || [];
+    }
+    /**
+     * 为群聊创建或获取活跃的 OpenCode 会话
+     * @param conversationId 群聊会话ID
+     * @param title 可选的会话标题
+     */
+    async ensureGroupActiveSession(conversationId, title) {
+        if (!this.client)
+            return null;
+        const session = this.groupSessions.get(conversationId);
+        if (!session)
+            return null;
+        if (!session.activeSessionId) {
+            const res = await this.client.session.create({
+                body: {
+                    title: title || `钉钉群聊: ${conversationId}`,
+                },
+            });
+            if (res.data?.id) {
+                session.activeSessionId = res.data.id;
+            }
+        }
+        return session.activeSessionId;
+    }
+}
+// ============ Backward Compatibility ============
+let defaultInstance = null;
+/**
+ * Returns the default (singleton) InstanceState.
+ * Kept for backward compatibility — new code should use
+ * explicit InstanceState instances via BotInstance / registry.
+ */
+export function getState() {
+    if (!defaultInstance) {
+        defaultInstance = new InstanceState("default");
+    }
+    return defaultInstance;
+}

package/dist/types/dingtalk-stub.js

@@ -0,0 +1,3 @@
+// Stub types for dingtalk-stream removed
+// These types are used in the codebase but the actual DWClient library has been removed
+export const TOPIC_ROBOT = "TOPIC_ROBOT";