@oyasmi/pipiclaw 0.1.0

package/dist/dingtalk.js

@@ -0,0 +1,655 @@
+/**
+ * DingTalk communication layer using dingtalk-stream SDK with AI Card streaming.
+ *
+ * Handles:
+ * - Receiving messages via DingTalk Stream Mode (DWClient)
+ * - Responding via AI Card (streaming) or plain markdown (fallback)
+ * - Access token management
+ * - Per-channel message queuing
+ */
+import axios from "axios";
+import { DWClient, TOPIC_ROBOT } from "dingtalk-stream";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import * as log from "./log.js";
+class ChannelQueue {
+    queue = [];
+    processing = false;
+    enqueue(work) {
+        this.queue.push(work);
+        this.processNext();
+    }
+    size() {
+        return this.queue.length;
+    }
+    async processNext() {
+        if (this.processing || this.queue.length === 0)
+            return;
+        this.processing = true;
+        const work = this.queue.shift();
+        try {
+            await work();
+        }
+        catch (err) {
+            log.logWarning("Queue error", err instanceof Error ? err.message : String(err));
+        }
+        this.processing = false;
+        this.processNext();
+    }
+}
+// ============================================================================
+// Constants
+// ============================================================================
+const DINGTALK_API = "https://api.dingtalk.com";
+const TOKEN_REFRESH_SECS = 90 * 60; // 1.5 hours (tokens expire after 2 hours)
+// ============================================================================
+// DingTalkBot
+// ============================================================================
+export class DingTalkBot {
+    handler;
+    config;
+    // Access token cache
+    accessToken = null;
+    tokenExpiry = 0;
+    // Active AI cards: channelId → AICard
+    activeCards = new Map();
+    // Conversation metadata cache: channelId → metadata
+    convMeta = new Map();
+    // Per-channel queues
+    queues = new Map();
+    // Connection stability
+    client = null;
+    lastSocketAvailableTime = Date.now();
+    activeMessageProcessing = false;
+    keepAliveTimer = null;
+    isReconnecting = false;
+    isStopped = false;
+    reconnectAttempts = 0;
+    // Deduplication cache (Set for O(1) lookup, order array for FIFO eviction)
+    processedIds = new Set();
+    processedIdsOrder = [];
+    constructor(handler, config) {
+        this.handler = handler;
+        this.config = config;
+    }
+    /**
+     * Mark an ID as processed. Returns true if this is a new ID, false if already seen.
+     * Maintains a FIFO buffer of at most 200 entries.
+     */
+    markProcessed(id) {
+        if (this.processedIds.has(id))
+            return false;
+        this.processedIds.add(id);
+        this.processedIdsOrder.push(id);
+        while (this.processedIdsOrder.length > 200) {
+            this.processedIds.delete(this.processedIdsOrder.shift());
+        }
+        return true;
+    }
+    // ==========================================================================
+    // Public API
+    // ==========================================================================
+    async start() {
+        if (!this.config.clientId || !this.config.clientSecret) {
+            log.logWarning("DingTalk: clientId / clientSecret not configured");
+            return;
+        }
+        if (!this.config.cardTemplateId) {
+            log.logWarning("DingTalk: cardTemplateId not configured — AI Card streaming will not work");
+        }
+        log.logInfo(`DingTalk: initializing stream (clientId=${this.config.clientId.substring(0, 8)}…)`);
+        if (process.env.DINGTALK_FORCE_PROXY !== "true") {
+            axios.defaults.proxy = false;
+        }
+        this.client = new DWClient({
+            clientId: this.config.clientId,
+            clientSecret: this.config.clientSecret,
+            autoReconnect: false,
+            keepAlive: false,
+        });
+        this.client.registerCallbackListener(TOPIC_ROBOT, (msg) => {
+            return this.handleRawMessage(msg);
+        });
+        log.logConnected();
+        await this.doReconnect(true); // Initial connection
+    }
+    handleRawMessage(msg) {
+        // 1. Immediate ACK
+        if (msg.headers?.messageId && this.client) {
+            this.client.socketCallBackResponse(msg.headers.messageId, { status: "SUCCESS", message: "OK" });
+        }
+        // 2. Protocol deduplication
+        const messageId = msg.headers?.messageId;
+        if (messageId && !this.markProcessed(messageId)) {
+            return { status: "SUCCESS", message: "OK" };
+        }
+        try {
+            const data = typeof msg.data === "string" ? JSON.parse(msg.data) : msg.data;
+            // 3. Business logic deduplication
+            const msgId = data.msgId;
+            if (msgId && !this.markProcessed(msgId)) {
+                return { status: "SUCCESS", message: "OK" };
+            }
+            // Fire-and-forget processing
+            this.onStreamMessage(data).catch((err) => {
+                log.logWarning("DingTalk handler error", err instanceof Error ? err.message : String(err));
+            });
+        }
+        catch (err) {
+            log.logWarning("DingTalk: failed to parse message", err instanceof Error ? err.message : String(err));
+        }
+        return { status: "SUCCESS", message: "OK" };
+    }
+    async doReconnect(immediate = false) {
+        if (this.isReconnecting || this.isStopped || !this.client)
+            return;
+        this.isReconnecting = true;
+        let connectionFailed = false;
+        if (!immediate && this.reconnectAttempts > 0) {
+            const delay = Math.min(1000 * 2 ** this.reconnectAttempts + Math.random() * 1000, 30000);
+            log.logInfo(`DingTalk: waiting ${Math.round(delay / 1000)}s before reconnecting...`);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+        try {
+            const socket = this.client.socket;
+            if (socket?.readyState === 1 || socket?.readyState === 3) {
+                await this.client.disconnect();
+            }
+            await this.client.connect();
+            this.lastSocketAvailableTime = Date.now();
+            this.reconnectAttempts = 0; // Success, reset backoff
+            log.logInfo("DingTalk: connected to stream.");
+            // Setup keep alive
+            if (this.keepAliveTimer)
+                clearInterval(this.keepAliveTimer);
+            this.keepAliveTimer = setInterval(() => {
+                if (this.isStopped)
+                    return;
+                const elapsed = Date.now() - this.lastSocketAvailableTime;
+                if (elapsed > 90 * 1000 && !this.activeMessageProcessing) {
+                    log.logWarning("DingTalk: connection timeout detected (>90s). Keeping active where possible...");
+                }
+                try {
+                    const s = this.client?.socket;
+                    if (s?.readyState === 1) {
+                        s.ping();
+                    }
+                }
+                catch (_err) {
+                    // Ignore
+                }
+            }, 30 * 1000);
+            // Setup native socket events
+            const s = this.client.socket;
+            s?.on("pong", () => {
+                this.lastSocketAvailableTime = Date.now();
+            });
+            s?.on("close", (code, reason) => {
+                log.logWarning(`DingTalk: WebSocket closed: code=${code}, reason=${reason}`);
+                if (this.isStopped)
+                    return;
+                setTimeout(() => {
+                    this.doReconnect(true).catch((err) => {
+                        log.logWarning("DingTalk: reconnect failed", err instanceof Error ? err.message : String(err));
+                    });
+                }, 1000);
+            });
+            s?.on("message", (raw) => {
+                try {
+                    const msg = JSON.parse(raw);
+                    if (msg.type === "SYSTEM" && msg.headers?.topic === "disconnect") {
+                        log.logWarning("DingTalk: disconnect event received from server.");
+                        if (!this.isStopped) {
+                            this.doReconnect(true).catch(() => { });
+                        }
+                    }
+                }
+                catch (_e) {
+                    // skip
+                }
+            });
+        }
+        catch (err) {
+            this.reconnectAttempts++;
+            connectionFailed = true;
+            log.logWarning("DingTalk: connection failed", err instanceof Error ? err.message : String(err));
+        }
+        finally {
+            this.isReconnecting = false;
+        }
+        // Auto-retry on failure with exponential backoff
+        if (connectionFailed && !this.isStopped) {
+            this.doReconnect().catch(() => { });
+        }
+    }
+    stop() {
+        this.isStopped = true;
+        if (this.keepAliveTimer)
+            clearInterval(this.keepAliveTimer);
+        if (this.client) {
+            try {
+                this.client.disconnect();
+            }
+            catch (_e) { }
+        }
+    }
+    /**
+     * Enqueue an event for processing.
+     * Returns true if enqueued, false if queue is full (max 5).
+     */
+    enqueueEvent(event) {
+        const queue = this.getQueue(event.channelId);
+        if (queue.size() >= 5) {
+            log.logWarning(`Event queue full for ${event.channelId}, discarding: ${event.text.substring(0, 50)}`);
+            return false;
+        }
+        log.logInfo(`Enqueueing event for ${event.channelId}: ${event.text.substring(0, 50)}`);
+        queue.enqueue(async () => {
+            this.activeMessageProcessing = true;
+            try {
+                await this.handler.handleEvent(event, this, true);
+            }
+            finally {
+                this.activeMessageProcessing = false;
+                this.lastSocketAvailableTime = Date.now();
+            }
+        });
+        return true;
+    }
+    // ==========================================================================
+    // AI Card operations
+    // ==========================================================================
+    /**
+     * Get or create an AI Card for a channel.
+     */
+    async ensureCard(channelId) {
+        if (!this.config.cardTemplateId)
+            return;
+        const existing = this.activeCards.get(channelId);
+        if (existing && !existing.finished)
+            return;
+        await this.createCard(channelId);
+    }
+    /**
+     * Stream content to the active AI Card for a channel.
+     */
+    async streamToCard(channelId, content, finalize = false) {
+        let card = this.activeCards.get(channelId);
+        if ((!card || card.finished) && !finalize && this.config.cardTemplateId && content.trim()) {
+            await this.ensureCard(channelId);
+            card = this.activeCards.get(channelId);
+        }
+        if (!card || card.finished) {
+            if (finalize) {
+                return this.sendPlain(channelId, content);
+            }
+            return false;
+        }
+        const streamed = await this.streamCard(card, content, finalize);
+        if (!streamed) {
+            this.activeCards.delete(channelId);
+        }
+        return streamed;
+    }
+    /**
+     * Finalize the active card for a channel without falling back to a plain message.
+     * Returns true if a card was finalized, false if no active card existed.
+     */
+    async finalizeExistingCard(channelId, content) {
+        let card = this.activeCards.get(channelId);
+        if ((!card || card.finished) && this.config.cardTemplateId && content.trim()) {
+            await this.ensureCard(channelId);
+            card = this.activeCards.get(channelId);
+        }
+        if (!card || card.finished) {
+            return false;
+        }
+        const finalized = await this.streamCard(card, content, true);
+        this.activeCards.delete(channelId);
+        return finalized;
+    }
+    /**
+     * Finalize and remove the active card for a channel.
+     */
+    async finalizeCard(channelId, content) {
+        const finalized = await this.finalizeExistingCard(channelId, content);
+        if (!finalized) {
+            return this.sendPlain(channelId, content);
+        }
+        return true;
+    }
+    discardCard(channelId) {
+        this.activeCards.delete(channelId);
+    }
+    /**
+     * Send a normal message natively mapping DM and Group to correct endpoints (fallback when no card).
+     */
+    async sendPlain(channelId, text) {
+        const token = await this.getAccessToken();
+        if (!token)
+            return false;
+        const meta = this.getConversationMeta(channelId);
+        if (!meta) {
+            log.logWarning(`No conversation metadata for ${channelId}, cannot send plain message`);
+            return false;
+        }
+        const robotCode = this.config.robotCode || this.config.clientId;
+        const isGroup = meta.conversationType === "2";
+        const hasMarkdown = /^#{1,6}\s|^\s*[-*]\s|\*\*.*\*\*|```|`[^`]+`|\[.*?\]\(.*?\)/m.test(text);
+        const msgKey = hasMarkdown ? "sampleMarkdown" : "sampleText";
+        const msgParam = hasMarkdown ? JSON.stringify({ text, title: "Bot" }) : JSON.stringify({ content: text });
+        const url = isGroup
+            ? `${DINGTALK_API}/v1.0/robot/groupMessages/send`
+            : `${DINGTALK_API}/v1.0/robot/oToMessages/batchSend`;
+        const body = {
+            robotCode,
+            msgKey,
+            msgParam,
+        };
+        if (isGroup) {
+            body.openConversationId = meta.conversationId;
+        }
+        else {
+            body.userIds = [meta.senderId];
+        }
+        try {
+            await axios.post(url, body, {
+                headers: {
+                    "x-acs-dingtalk-access-token": token,
+                    "Content-Type": "application/json",
+                },
+            });
+            return true;
+        }
+        catch (err) {
+            if (axios.isAxiosError(err) && err.response) {
+                log.logWarning(`DingTalk plain send failed (${err.response.status})`, JSON.stringify(err.response.data));
+            }
+            else {
+                log.logWarning("DingTalk plain send error", err instanceof Error ? err.message : String(err));
+            }
+            return false;
+        }
+    }
+    // ==========================================================================
+    // Private - AI Card implementation
+    // ==========================================================================
+    async createCard(channelId) {
+        const token = await this.getAccessToken();
+        if (!token)
+            return null;
+        const meta = this.getConversationMeta(channelId);
+        if (!meta) {
+            log.logWarning(`No conversation metadata for ${channelId}, cannot create card`);
+            return null;
+        }
+        const isGroup = meta.conversationType === "2";
+        const instanceId = `card_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+        const robotCode = this.config.robotCode || this.config.clientId;
+        // openSpaceId format:
+        //   群聊: dtv1.card//IM_GROUP.{openConversationId}
+        //   单聊: dtv1.card//IM_ROBOT.{userId}
+        const openSpaceId = isGroup
+            ? `dtv1.card//IM_GROUP.${meta.conversationId}`
+            : `dtv1.card//IM_ROBOT.${meta.senderId}`;
+        const body = {
+            cardTemplateId: this.config.cardTemplateId,
+            outTrackId: instanceId,
+            cardData: { cardParamMap: {} },
+            callbackType: "STREAM",
+            imGroupOpenSpaceModel: { supportForward: true },
+            imRobotOpenSpaceModel: { supportForward: true },
+            openSpaceId,
+            userIdType: 1,
+        };
+        if (isGroup) {
+            body.imGroupOpenDeliverModel = { robotCode };
+        }
+        else {
+            body.imRobotOpenDeliverModel = { spaceType: "IM_ROBOT" };
+        }
+        try {
+            await axios.post(`${DINGTALK_API}/v1.0/card/instances/createAndDeliver`, body, {
+                headers: {
+                    "x-acs-dingtalk-access-token": token,
+                    "Content-Type": "application/json",
+                },
+            });
+        }
+        catch (err) {
+            if (axios.isAxiosError(err) && err.response) {
+                log.logWarning(`DingTalk Card: create failed (${err.response.status})`, JSON.stringify(err.response.data));
+            }
+            else {
+                log.logWarning("DingTalk Card: create failed", err instanceof Error ? err.message : String(err));
+            }
+            return null;
+        }
+        const card = {
+            instanceId,
+            conversationId: meta.conversationId,
+            accessToken: token,
+            templateKey: this.config.cardTemplateKey || "content",
+            createdAt: Date.now() / 1000,
+            lastUpdated: Date.now() / 1000,
+            content: "",
+            finished: false,
+        };
+        this.activeCards.set(channelId, card);
+        return card;
+    }
+    async streamCard(card, content, finalize = false) {
+        // Refresh token if needed
+        const ageSecs = Date.now() / 1000 - card.createdAt;
+        if (ageSecs > TOKEN_REFRESH_SECS) {
+            const token = await this.getAccessToken();
+            if (token) {
+                card.accessToken = token;
+            }
+        }
+        const body = {
+            outTrackId: card.instanceId,
+            guid: `${Date.now()}_${Math.random().toString(36).substring(2, 8)}`,
+            key: card.templateKey,
+            content,
+            isFull: true,
+            isFinalize: finalize,
+            isError: false,
+        };
+        const start = Date.now();
+        try {
+            await axios.put(`${DINGTALK_API}/v1.0/card/streaming`, body, {
+                headers: {
+                    "x-acs-dingtalk-access-token": card.accessToken,
+                    "Content-Type": "application/json",
+                },
+            });
+            const duration = Date.now() - start;
+            if (duration > 1000) {
+                log.logWarning(`DingTalk Card: streaming request took ${duration}ms (slow)`);
+            }
+            card.lastUpdated = Date.now() / 1000;
+            card.content = content;
+            if (finalize) {
+                card.finished = true;
+            }
+            return true;
+        }
+        catch (err) {
+            if (axios.isAxiosError(err) && err.response) {
+                log.logWarning(`DingTalk Card: streaming failed (${err.response.status})`, JSON.stringify(err.response.data));
+            }
+            else {
+                log.logWarning("DingTalk Card: streaming failed", err instanceof Error ? err.message : String(err));
+            }
+            return false;
+        }
+    }
+    // ==========================================================================
+    // Private - Access Token
+    // ==========================================================================
+    async getAccessToken() {
+        if (this.accessToken && Date.now() / 1000 < this.tokenExpiry) {
+            return this.accessToken;
+        }
+        try {
+            const resp = await axios.post(`${DINGTALK_API}/v1.0/oauth2/accessToken`, {
+                appKey: this.config.clientId,
+                appSecret: this.config.clientSecret,
+            }, {
+                headers: { "Content-Type": "application/json" },
+            });
+            const data = resp.data;
+            this.accessToken = data.accessToken || null;
+            this.tokenExpiry = Date.now() / 1000 + (data.expireIn || 7200) - 60;
+            return this.accessToken;
+        }
+        catch (err) {
+            if (axios.isAxiosError(err) && err.response) {
+                log.logWarning(`DingTalk: failed to get access token (${err.response.status})`, JSON.stringify(err.response.data));
+            }
+            else {
+                log.logWarning("DingTalk: failed to get access token", err instanceof Error ? err.message : String(err));
+            }
+            return null;
+        }
+    }
+    // ==========================================================================
+    // Private - Message handling
+    // ==========================================================================
+    extractContent(data) {
+        // 1. text 类型消息：从 text.content 提取
+        const textContent = (data.text?.content || "").trim();
+        if (textContent)
+            return textContent;
+        // 2. richText 类型消息：从 content.richText 列表提取文本片段
+        const raw = data;
+        const contentObj = raw.content;
+        if (contentObj?.richText) {
+            const parts = [];
+            for (const item of contentObj.richText) {
+                if (item.text)
+                    parts.push(item.text);
+            }
+            const joined = parts.join("").trim();
+            if (joined)
+                return joined;
+        }
+        return "";
+    }
+    async onStreamMessage(data) {
+        const content = this.extractContent(data);
+        const senderId = data.senderStaffId || data.senderId || "";
+        const senderName = data.senderNick || "Unknown";
+        const conversationId = data.conversationId || "";
+        const conversationType = data.conversationType || "1";
+        if (!content) {
+            const msgtype = data.msgtype || "unknown";
+            log.logWarning(`DingTalk: empty message (type=${msgtype})`);
+            return;
+        }
+        if (this.config.allowFrom && this.config.allowFrom.length > 0) {
+            if (!this.config.allowFrom.includes(senderId)) {
+                log.logWarning(`DingTalk: ignoring message from unauthorized user ${senderName} (${senderId})`);
+                return;
+            }
+        }
+        // Determine channel ID
+        const channelId = conversationType === "2" ? `group_${conversationId}` : `dm_${senderId}`;
+        log.logInfo(`DingTalk ← ${senderName} (${senderId}) [${channelId}]: ${content.substring(0, 80)}`);
+        // Cache conversation metadata for card creation
+        this.setConversationMeta(channelId, {
+            conversationId,
+            conversationType,
+            senderId,
+        });
+        // Build event
+        const event = {
+            type: conversationType === "2" ? "group" : "dm",
+            channelId,
+            ts: Date.now().toString(),
+            user: senderId,
+            userName: senderName,
+            text: content,
+            conversationId,
+            conversationType,
+        };
+        // Check for stop command
+        if (content.toLowerCase().trim() === "stop") {
+            if (this.handler.isRunning(channelId)) {
+                this.handler.handleStop(channelId, this);
+            }
+            return;
+        }
+        // Check if busy
+        if (this.handler.isRunning(channelId)) {
+            const busyMsg = "正在处理中，请稍候。发送 `stop` 可取消当前任务。";
+            await this.sendPlain(channelId, busyMsg);
+            return;
+        }
+        // Enqueue for processing
+        this.getQueue(channelId).enqueue(async () => {
+            this.activeMessageProcessing = true;
+            try {
+                await this.handler.handleEvent(event, this);
+            }
+            finally {
+                this.activeMessageProcessing = false;
+                this.lastSocketAvailableTime = Date.now();
+            }
+        });
+    }
+    getQueue(channelId) {
+        let queue = this.queues.get(channelId);
+        if (!queue) {
+            queue = new ChannelQueue();
+            this.queues.set(channelId, queue);
+        }
+        return queue;
+    }
+    getConversationMeta(channelId) {
+        const cached = this.convMeta.get(channelId);
+        if (cached)
+            return cached;
+        const metaPath = this.getConversationMetaPath(channelId);
+        if (!metaPath || !existsSync(metaPath)) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(readFileSync(metaPath, "utf-8"));
+            if (!parsed.conversationId || !parsed.conversationType || !parsed.senderId) {
+                return null;
+            }
+            const meta = {
+                conversationId: parsed.conversationId,
+                conversationType: parsed.conversationType,
+                senderId: parsed.senderId,
+            };
+            this.convMeta.set(channelId, meta);
+            return meta;
+        }
+        catch (err) {
+            log.logWarning(`Failed to load conversation metadata for ${channelId}`, err instanceof Error ? err.message : String(err));
+            return null;
+        }
+    }
+    setConversationMeta(channelId, meta) {
+        this.convMeta.set(channelId, meta);
+        const metaPath = this.getConversationMetaPath(channelId);
+        if (!metaPath)
+            return;
+        try {
+            mkdirSync(dirname(metaPath), { recursive: true });
+            writeFileSync(metaPath, JSON.stringify(meta, null, 2), "utf-8");
+        }
+        catch (err) {
+            log.logWarning(`Failed to persist conversation metadata for ${channelId}`, err instanceof Error ? err.message : String(err));
+        }
+    }
+    getConversationMetaPath(channelId) {
+        if (!this.config.stateDir)
+            return null;
+        return join(this.config.stateDir, channelId, ".channel-meta.json");
+    }
+}
+//# sourceMappingURL=dingtalk.js.map