pikiloop 0.4.0

package/dist/channels/dingtalk/channel.js

@@ -0,0 +1,268 @@
+/**
+ * DingTalk channel transport — Stream Mode (no public IP needed).
+ *
+ * Uses dingtalk-stream@2.x SDK. Auth: clientId (AppKey) + clientSecret
+ * (AppSecret) of a self-built robot/app subscribed to the bot message topic.
+ *
+ * Receive: DWClient subscribes to TOPIC_ROBOT and yields RobotTextMessage
+ * payloads via registerCallbackListener.
+ *
+ * Send: each inbound message carries a `sessionWebhook` URL valid for ~2 hours,
+ * which we POST to for replies. We cache the latest sessionWebhook per chat
+ * so a long-running task that produces a result message can still reach the
+ * user even after the original webhook would have expired (mid-conversation
+ * activity refreshes it). DingTalk plain-text messages cannot be edited.
+ */
+import { DWClient, TOPIC_ROBOT, EventAck } from 'dingtalk-stream';
+import { Channel, DEFAULT_CHANNEL_CAPABILITIES, splitText, sleep, } from '../base.js';
+import { DINGTALK_LIMITS } from '../../core/constants.js';
+import { ChannelHealth } from '../health.js';
+import { writeScopedLog } from '../../core/logging.js';
+const DT_MAX = DINGTALK_LIMITS.maxMessageLength;
+function describeError(err) {
+    return err instanceof Error ? err.message : String(err ?? 'unknown error');
+}
+function previewText(value, max = 200) {
+    const t = value.replace(/\s+/g, ' ').trim();
+    return t.length > max ? `${t.slice(0, max)}...` : t || '(empty)';
+}
+export class DingtalkChannel extends Channel {
+    capabilities = {
+        ...DEFAULT_CHANNEL_CAPABILITIES,
+        // DingTalk Stream Mode plain-text messages cannot be edited; AI Cards
+        // can be updated but are out of scope for this minimal channel.
+    };
+    knownChats = new Set();
+    clientId;
+    clientSecret;
+    allowedChatIds;
+    dwClient = null;
+    running = false;
+    listenResolve = null;
+    chatMeta = new Map();
+    messageHandlers = new Set();
+    errorHandlers = new Set();
+    /** Dedup: stream may redeliver after timeouts. */
+    seenMsgIds = new Set();
+    seenMsgIdQueue = [];
+    static SEEN_CAP = 256;
+    constructor(opts) {
+        super();
+        this.clientId = opts.clientId;
+        this.clientSecret = opts.clientSecret;
+        this.allowedChatIds = opts.allowedChatIds;
+    }
+    onMessage(handler) { this.messageHandlers.add(handler); return this; }
+    onError(handler) { this.errorHandlers.add(handler); return this; }
+    // ========================================================================
+    // Lifecycle
+    // ========================================================================
+    async connect() {
+        this.dwClient = new DWClient({
+            clientId: this.clientId,
+            clientSecret: this.clientSecret,
+            keepAlive: true,
+        });
+        let lastErr = null;
+        for (let attempt = 1; attempt <= 5; attempt++) {
+            try {
+                await this.dwClient.getAccessToken();
+                const shortId = this.clientId.length > 12
+                    ? `${this.clientId.slice(0, 6)}...${this.clientId.slice(-4)}`
+                    : this.clientId;
+                this.bot = {
+                    id: this.clientId,
+                    username: `dingtalk_${shortId}`,
+                    displayName: `DingTalk ${shortId}`,
+                };
+                return this.bot;
+            }
+            catch (err) {
+                lastErr = err;
+                if (attempt >= 5)
+                    break;
+                await sleep(Math.min(1000 * attempt, 5_000));
+            }
+        }
+        throw new Error(`DingTalk connect failed: ${describeError(lastErr)}`);
+    }
+    async listen() {
+        if (!this.dwClient)
+            throw new Error('DingTalk channel not connected');
+        this.running = true;
+        this.dwClient.registerCallbackListener(TOPIC_ROBOT, (msg) => {
+            void this.dispatchRobotMessage(msg).catch(error => {
+                this.emitError(error instanceof Error ? error : new Error(describeError(error)));
+            });
+        });
+        const health = new ChannelHealth({
+            label: 'DingTalk',
+            opAction: 'WS connect',
+            initialDelayMs: DINGTALK_LIMITS.initialRetryDelay,
+            maxDelayMs: DINGTALK_LIMITS.maxRetryDelay,
+            sustainedFailureHint: 'verify dingtalkClientId / dingtalkClientSecret in setting.json',
+            log: (msg, level) => this.log(msg, level),
+        });
+        while (this.running) {
+            try {
+                await this.dwClient.connect();
+                health.recordSuccess();
+                break;
+            }
+            catch (err) {
+                if (!this.running)
+                    return;
+                await sleep(health.recordFailure(err));
+            }
+        }
+        if (!this.running)
+            return;
+        await new Promise(resolve => {
+            this.listenResolve = resolve;
+            if (!this.running)
+                resolve();
+        });
+    }
+    disconnect() {
+        this.running = false;
+        try {
+            this.dwClient?.disconnect();
+        }
+        catch { }
+        this.dwClient = null;
+        this.listenResolve?.();
+        this.listenResolve = null;
+    }
+    // ========================================================================
+    // Outgoing primitives
+    // ========================================================================
+    async send(chatId, text, _opts = {}) {
+        const chat = String(chatId);
+        const meta = this.chatMeta.get(chat);
+        if (!meta?.sessionWebhook) {
+            throw new Error(`DingTalk has no active sessionWebhook for chat ${chat}; user must send a message first.`);
+        }
+        if (meta.sessionWebhookExpiredAt && Date.now() > meta.sessionWebhookExpiredAt) {
+            this.debug(`[send] sessionWebhook for ${chat} likely expired — attempting anyway`);
+        }
+        const trimmed = (text || '').trim() || '(empty)';
+        const chunks = splitText(trimmed, DT_MAX);
+        let lastId = null;
+        for (let i = 0; i < chunks.length; i++) {
+            const chunk = chunks[i];
+            this.debug(`[send] chat=${chat} chunk=${i + 1}/${chunks.length} chars=${chunk.length} preview=${previewText(chunk)}`);
+            const resp = await fetch(meta.sessionWebhook, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ msgtype: 'text', text: { content: chunk } }),
+            });
+            const body = await resp.text();
+            if (!resp.ok) {
+                throw new Error(`DingTalk reply failed: HTTP ${resp.status} ${resp.statusText || ''}; body=${previewText(body)}`);
+            }
+            try {
+                const data = JSON.parse(body);
+                if (typeof data?.errcode === 'number' && data.errcode !== 0) {
+                    throw new Error(`DingTalk reply errcode=${data.errcode} errmsg=${data.errmsg || 'unknown'}`);
+                }
+            }
+            catch (err) {
+                if (err instanceof Error && err.message.startsWith('DingTalk reply errcode='))
+                    throw err;
+                // Non-JSON body or no errcode is treated as success.
+            }
+            lastId = `dt:${Date.now().toString(36)}:${i}`;
+        }
+        return lastId;
+    }
+    async editMessage(_chatId, _msgId, _text, _opts) {
+        // Plain-text messages on DingTalk are not editable. AI Cards have an
+        // update API but require pre-registering a card template — out of scope
+        // for this transport. Callers that fall back here just no-op.
+    }
+    async deleteMessage(_chatId, _msgId) {
+        // No public delete API for bot-sent messages.
+    }
+    async sendTyping(_chatId, _opts) {
+        // No typing indicator API.
+    }
+    // ========================================================================
+    // Internal dispatch
+    // ========================================================================
+    async dispatchRobotMessage(msg) {
+        try {
+            this.dwClient?.socketCallBackResponse(msg.headers.messageId, { status: EventAck.SUCCESS });
+        }
+        catch { }
+        let parsed;
+        try {
+            parsed = JSON.parse(msg.data);
+        }
+        catch (err) {
+            this.emitError(new Error(`DingTalk message parse failed: ${describeError(err)}`));
+            return;
+        }
+        if (!parsed)
+            return;
+        const chatId = String(parsed.conversationId || '').trim();
+        const messageId = String(parsed.msgId || '').trim();
+        const senderId = String(parsed.senderStaffId || parsed.senderId || '').trim();
+        if (!chatId || !messageId || !senderId)
+            return;
+        if (this.seenMsgIds.has(messageId))
+            return;
+        this.seenMsgIds.add(messageId);
+        this.seenMsgIdQueue.push(messageId);
+        while (this.seenMsgIdQueue.length > DingtalkChannel.SEEN_CAP) {
+            this.seenMsgIds.delete(this.seenMsgIdQueue.shift());
+        }
+        if (!this.isAllowed(chatId))
+            return;
+        this.knownChats.add(chatId);
+        if (parsed.sessionWebhook) {
+            this.chatMeta.set(chatId, {
+                sessionWebhook: parsed.sessionWebhook,
+                sessionWebhookExpiredAt: Number(parsed.sessionWebhookExpiredTime) || Date.now() + 60 * 60_000,
+            });
+        }
+        let text = '';
+        if (parsed.msgtype === 'text' && parsed.text?.content)
+            text = String(parsed.text.content || '').trim();
+        else
+            this.debug(`[recv] non-text msgtype=${parsed.msgtype} chat=${chatId} msg=${messageId}`);
+        const ctx = {
+            chatId,
+            messageId,
+            conversationType: String(parsed.conversationType || ''),
+            from: { userId: senderId, displayName: parsed.senderNick },
+            reply: (replyText, opts) => this.send(chatId, replyText, opts),
+            editReply: () => Promise.resolve(),
+            channel: this,
+            raw: parsed,
+        };
+        const payload = { text, files: [] };
+        for (const handler of this.messageHandlers) {
+            try {
+                await handler(payload, ctx);
+            }
+            catch (error) {
+                this.emitError(error instanceof Error ? error : new Error(describeError(error)));
+            }
+        }
+    }
+    isAllowed(chatId) {
+        if (!this.allowedChatIds?.size)
+            return true;
+        return this.allowedChatIds.has(chatId);
+    }
+    emitError(error) {
+        for (const handler of this.errorHandlers) {
+            try {
+                handler(error);
+            }
+            catch { }
+        }
+    }
+    debug(msg) { this.log(msg, 'debug'); }
+    log(msg, level = 'info') { writeScopedLog('dingtalk', msg, { level }); }
+}