@zhin.js/adapter-dingtalk 4.0.1 → 4.0.3

package/lib/endpoint.js

@@ -1,418 +1,141 @@
-/**
- * 钉钉 Endpoint 实现
- */
-import { formatCompact, Message, segment, expandInteractiveSegmentsInContent, } from 'zhin.js';
-import { registerFetchRoute } from "@zhin.js/host-router/router";
-import { createHmac } from "crypto";
-import { normalizeDingtalkSenderForPermit } from "./platform-permit.js";
-import { fromCanonicalSegments, toCanonicalSegments } from './segment-mapper.js';
+import { formatCompact, getLogger } from '@zhin.js/logger';
+import { registerDingtalkAgentEndpoint } from './dingtalk-agent-deps.js';
+import { normalizeDingtalkSenderForPermit } from './platform-permit.js';
+import { formatInboundContent, formatOutboundBody, generateMessageId, isDingtalkBotMentioned, resolveChatType, resolveSender, resolveTarget, } from './protocol.js';
+import { registerDingTalkWebhookRoutes } from './webhook.js';
+const logger = getLogger('dingtalk');
 export class DingTalkEndpoint {
-    adapter;
-    $config;
-    $connected;
-    router;
-    accessToken;
-    baseURL;
-    sessionWebhooks = new Map();
-    get $id() {
-        return this.$config.name;
+    #options;
+    #fetch;
+    #routeReleases = [];
+    #accessToken = { token: '', expires_in: 0, timestamp: 0 };
+    #refreshPromise = null;
+    #sessionWebhooks = new Map();
+    #open = false;
+    #started = false;
+    #unregisterAgent;
+    constructor(options) {
+        this.#options = options;
+        this.#fetch = options.fetch ?? globalThis.fetch;
     }
-    get logger() {
-        return this.adapter.plugin.logger;
+    /** Used by webhook handler. */
+    get isOpen() {
+        return this.#open;
     }
-    constructor(adapter, router, $config) {
-        this.adapter = adapter;
-        this.$config = $config;
-        this.router = router;
-        this.$connected = false;
-        this.accessToken = { token: "", expires_in: 0, timestamp: 0 };
-        this.baseURL = $config.apiBaseUrl || "https://oapi.dingtalk.com";
-        this.setupWebhookRoute();
+    get config() {
+        return this.#options.config;
     }
-    async request(path, options = {}) {
-        await this.ensureAccessToken();
-        const { method = "GET", params = {}, body } = options;
-        const urlParams = new URLSearchParams({
-            ...params,
-            access_token: this.accessToken.token,
-        });
-        const url = `${this.baseURL}${path}?${urlParams.toString()}`;
-        const fetchOptions = {
-            method,
-            headers: {
-                "Content-Type": "application/json; charset=utf-8",
-            },
-        };
-        if (body && method === "POST") {
-            fetchOptions.body = JSON.stringify(body);
-        }
-        const response = await fetch(url, fetchOptions);
-        return await response.json();
-    }
-    setupWebhookRoute() {
-        registerFetchRoute(this.router, "POST", this.$config.webhookPath, (ctx) => {
-            void this.handleWebhook(ctx);
-        });
-    }
-    async handleWebhook(ctx) {
+    async start() {
+        if (this.#started)
+            return;
+        this.#started = true;
         try {
-            const body = ctx.request.body;
-            const timestamp = ctx.get("timestamp");
-            const sign = ctx.get("sign");
-            if (timestamp && sign) {
-                if (!this.verifySignature(timestamp, sign)) {
-                    this.logger.warn(formatCompact({ op: "webhook", ok: false, error: "invalid signature" }));
-                    ctx.status = 403;
-                    ctx.body = { code: -1, msg: "Forbidden" };
-                    return;
-                }
-            }
-            const event = body;
-            if (event.msgtype) {
-                await this.handleEvent(event);
-            }
-            ctx.status = 200;
-            ctx.body = { code: 0, msg: "success" };
+            await this.#refreshAccessToken();
+            this.#unregisterAgent = registerDingtalkAgentEndpoint(this.#options.config.name, this);
+            this.#routeReleases.push(...registerDingTalkWebhookRoutes(this.#options.http, this));
+            logger.debug(formatCompact({
+                endpoint: this.#options.config.name,
+                op: 'webhook',
+                path: this.#options.config.webhookPath,
+            }));
         }
         catch (error) {
-            this.logger.error("Webhook error:", error);
-            ctx.status = 500;
-            ctx.body = { code: -1, msg: "Internal Server Error" };
+            await this.stop();
+            logger.error('Failed to connect DingTalk endpoint:', error);
+            throw error;
         }
     }
-    verifySignature(timestamp, sign) {
-        try {
-            const stringToSign = `${timestamp}\n${this.$config.appSecret}`;
-            const hmac = createHmac("sha256", this.$config.appSecret);
-            hmac.update(stringToSign);
-            const calculatedSign = hmac.digest("base64");
-            return calculatedSign === sign;
-        }
-        catch (error) {
-            this.logger.error("Signature verification error:", error);
-            return false;
-        }
+    open() {
+        this.#open = true;
     }
-    async handleEvent(event) {
-        if (event.sessionWebhook && event.conversationId) {
-            this.sessionWebhooks.set(event.conversationId, event.sessionWebhook);
-        }
-        const message = this.$formatMessage(event);
-        this.adapter.emit("message.receive", message);
-        this.logger.debug(formatCompact({
-            op: "recv",
-            endpoint: this.$config.name,
-            channel: message.$channel.type,
-            id: message.$channel.id,
-            len: segment.raw(message.$content).length,
-        }));
+    close() {
+        this.#open = false;
     }
-    async ensureAccessToken() {
-        const now = Date.now();
-        if (this.accessToken.token &&
-            now <
-                this.accessToken.timestamp +
-                    (this.accessToken.expires_in - 300) * 1000) {
-            return;
-        }
-        await this.refreshAccessToken();
+    async stop() {
+        this.#open = false;
+        this.#sessionWebhooks.clear();
+        for (const release of this.#routeReleases.splice(0))
+            release();
+        this.#unregisterAgent?.();
+        this.#unregisterAgent = undefined;
+        this.#started = false;
+        logger.debug(formatCompact({ op: 'disconnect', endpoint: this.#options.config.name }));
     }
-    async refreshAccessToken() {
-        try {
-            const baseURL = this.$config.apiBaseUrl || "https://oapi.dingtalk.com";
-            const params = new URLSearchParams({
-                appkey: this.$config.appKey,
-                appsecret: this.$config.appSecret,
+    async send({ target, payload }) {
+        const content = formatOutboundBody(payload);
+        const sessionWebhook = this.#sessionWebhooks.get(target);
+        if (sessionWebhook) {
+            const response = await this.#fetch(sessionWebhook, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json; charset=utf-8' },
+                body: JSON.stringify(content),
             });
-            const url = `${baseURL}/gettoken?${params.toString()}`;
-            const response = await fetch(url);
             const data = await response.json();
-            if (data.errcode === 0) {
-                this.accessToken = {
-                    token: data.access_token,
-                    expires_in: data.expires_in,
-                    timestamp: Date.now(),
-                };
-                this.logger.debug("Access token refreshed successfully");
-            }
-            else {
-                throw new Error(`Failed to get access token: ${data.errmsg}`);
+            if (data.errcode !== 0) {
+                throw new Error(`Failed to send message via session webhook: ${data.errmsg}`);
             }
+            logger.debug(formatCompact({
+                op: 'send',
+                endpoint: this.#options.config.name,
+                via: 'sessionWebhook',
+                to: target,
+            }));
+            return data.msgId || `${Date.now()}`;
+        }
+        const body = {
+            ...content,
+            ...(this.#options.config.robotCode
+                ? { robotCode: this.#options.config.robotCode }
+                : {}),
+        };
+        const data = await this.#request('/robot/send', {
+            method: 'POST',
+            body: body,
+        });
+        if (data.errcode !== 0) {
+            throw new Error(`Failed to send message: ${data.errmsg}`);
         }
-        catch (error) {
-            this.logger.error("Failed to refresh access token:", error);
-            throw error;
-        }
+        logger.debug(formatCompact({ op: 'send', endpoint: this.#options.config.name, to: target }));
+        return data.msgId || `${Date.now()}`;
     }
-    $formatMessage(msg) {
-        const wire = this.parseMessageContent(msg);
-        const content = toCanonicalSegments(wire);
-        const chatType = msg.conversationType === "2" ? "group" : "private";
-        const permit = normalizeDingtalkSenderForPermit({ isAdmin: msg.isAdmin === true });
-        return Message.from(msg, {
-            $id: msg.msgId || Date.now().toString(),
-            $adapter: "dingtalk",
-            $endpoint: this.$config.name,
-            $sender: {
-                id: msg.senderId || msg.senderStaffId || "unknown",
-                name: msg.senderNick || msg.senderId || "Unknown User",
+    /** Test / internal: admit a parsed event when open (non-webhook path). */
+    admit(event) {
+        if (!this.#open)
+            return;
+        if (event.sessionWebhook && event.conversationId) {
+            this.#sessionWebhooks.set(event.conversationId, event.sessionWebhook);
+        }
+        const target = resolveTarget(event);
+        const chatType = resolveChatType(event.conversationType);
+        const permit = normalizeDingtalkSenderForPermit({ isAdmin: event.isAdmin === true });
+        void this.#options.gateway.receive({
+            adapter: this.#options.id,
+            target,
+            content: formatInboundContent(event),
+            sender: resolveSender(event),
+            id: generateMessageId(event),
+            metadata: Object.freeze({
+                msgtype: event.msgtype,
+                chatType,
+                endpoint: this.#options.config.name,
+                senderNick: event.senderNick,
                 role: permit.role,
                 permissions: permit.permissions,
-            },
-            $channel: {
-                id: msg.conversationId || "unknown",
-                type: chatType,
-            },
-            $content: content,
-            $raw: JSON.stringify(msg),
-            $timestamp: msg.createAt || Date.now(),
-            $recall: async () => {
-                await this.$recallMessage(msg.msgId || "");
-            },
-            $reply: async (content) => {
-                return await this.adapter.sendMessage({
-                    context: "dingtalk",
-                    endpoint: this.$config.name,
-                    id: msg.conversationId || msg.senderId || "unknown",
-                    type: chatType,
-                    content: content,
-                });
-            },
+                conversationType: event.conversationType,
+                ...(isDingtalkBotMentioned(event, this.#options.config.robotCode) ? { mentioned: true } : {}),
+            }),
+        }).catch((err) => {
+            logger.warn(formatCompact({
+                op: 'dingtalk_gateway_receive_failed',
+                target,
+                error: err instanceof Error ? err.message : String(err),
+            }));
         });
     }
-    parseMessageContent(msg) {
-        const content = [];
-        if (!msg.msgtype)
-            return content;
-        try {
-            switch (msg.msgtype) {
-                case "text":
-                    if (msg.text?.content) {
-                        content.push(segment("text", { content: msg.text.content }));
-                        if (msg.atUsers && msg.atUsers.length > 0) {
-                            for (const atUser of msg.atUsers) {
-                                content.push(segment("at", {
-                                    id: atUser.dingtalkId || atUser.staffId,
-                                    name: atUser.dingtalkId || atUser.staffId,
-                                }));
-                            }
-                        }
-                    }
-                    break;
-                case "picture":
-                    if (msg.content) {
-                        content.push(segment("image", {
-                            url: msg.content.downloadCode ||
-                                msg.content.pictureDownloadCode,
-                            file: msg.content.downloadCode ||
-                                msg.content.pictureDownloadCode,
-                        }));
-                    }
-                    break;
-                case "file":
-                    if (msg.content) {
-                        content.push(segment("file", {
-                            file: msg.content.downloadCode,
-                            name: msg.content.fileName,
-                            size: msg.content.fileSize,
-                        }));
-                    }
-                    break;
-                case "audio":
-                    if (msg.content) {
-                        content.push(segment("audio", {
-                            file: msg.content.downloadCode,
-                            duration: msg.content.duration,
-                        }));
-                    }
-                    break;
-                case "video":
-                    if (msg.content) {
-                        content.push(segment("video", {
-                            file: msg.content.downloadCode,
-                            duration: msg.content.duration,
-                            size: msg.content.videoSize,
-                        }));
-                    }
-                    break;
-                case "richText":
-                    if (msg.content?.richText) {
-                        for (const item of msg.content.richText) {
-                            if (item.text) {
-                                content.push(segment("text", { content: item.text }));
-                            }
-                        }
-                    }
-                    break;
-                case "markdown":
-                    if (msg.content?.text) {
-                        content.push(segment("markdown", {
-                            content: msg.content.text,
-                            title: msg.content.title,
-                        }));
-                    }
-                    break;
-                default:
-                    content.push(segment("text", {
-                        content: `[不支持的消息类型: ${msg.msgtype}]`,
-                    }));
-                    break;
-            }
-        }
-        catch (error) {
-            this.logger.error("Failed to parse message content:", error);
-            content.push(segment("text", { content: "[消息解析失败]" }));
-        }
-        return content;
-    }
-    async $sendMessage(options) {
-        const conversationId = options.id;
-        const canonical = expandInteractiveSegmentsInContent(options.content);
-        const wire = fromCanonicalSegments(canonical);
-        const content = this.formatSendContent(wire);
-        try {
-            const sessionWebhook = this.sessionWebhooks.get(conversationId);
-            if (sessionWebhook) {
-                const response = await fetch(sessionWebhook, {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json; charset=utf-8",
-                    },
-                    body: JSON.stringify(content),
-                });
-                const data = await response.json();
-                if (data.errcode !== 0) {
-                    throw new Error(`Failed to send message via session webhook: ${data.errmsg}`);
-                }
-                this.logger.debug("Message sent via session webhook");
-                return data.msgId || Date.now().toString();
-            }
-            const data = await this.request("/robot/send", {
-                method: "POST",
-                body: {
-                    ...content,
-                    robotCode: this.$config.robotCode,
-                },
-            });
-            if (data.errcode !== 0) {
-                throw new Error(`Failed to send message: ${data.errmsg}`);
-            }
-            this.logger.debug("Message sent successfully");
-            return data.msgId || Date.now().toString();
-        }
-        catch (error) {
-            this.logger.error("Failed to send message:", error);
-            throw error;
-        }
-    }
-    async $recallMessage(id) {
-        this.logger.warn(formatCompact({ op: "recall", ok: false, error: "not supported" }));
-    }
-    formatSendContent(content) {
-        if (typeof content === "string") {
-            return { msgtype: "text", text: { content } };
-        }
-        if (Array.isArray(content)) {
-            const textParts = [];
-            const atUserIds = [];
-            let hasMedia = false;
-            let mediaContent = null;
-            for (const item of content) {
-                if (typeof item === "string") {
-                    textParts.push(item);
-                }
-                else {
-                    const seg = item;
-                    switch (seg.type) {
-                        case "text":
-                            textParts.push(seg.data.content || seg.data.text || "");
-                            break;
-                        case "at":
-                            const userId = seg.data.id || seg.data.userId;
-                            if (userId) {
-                                atUserIds.push(userId);
-                                textParts.push(`@${seg.data.name || userId} `);
-                            }
-                            break;
-                        case "image":
-                            if (!hasMedia) {
-                                hasMedia = true;
-                                mediaContent = {
-                                    msgtype: "picture",
-                                    picture: {
-                                        picURL: seg.data.url || seg.data.file,
-                                    },
-                                };
-                            }
-                            break;
-                        case "markdown":
-                            if (!hasMedia) {
-                                hasMedia = true;
-                                mediaContent = {
-                                    msgtype: "markdown",
-                                    markdown: {
-                                        title: seg.data.title || "消息",
-                                        text: seg.data.content || seg.data.text,
-                                    },
-                                };
-                            }
-                            break;
-                        case "link":
-                            if (!hasMedia) {
-                                hasMedia = true;
-                                mediaContent = {
-                                    msgtype: "link",
-                                    link: {
-                                        title: seg.data.title || "链接",
-                                        text: seg.data.text || seg.data.content || "",
-                                        messageUrl: seg.data.url,
-                                        picUrl: seg.data.picUrl,
-                                    },
-                                };
-                            }
-                            break;
-                    }
-                }
-            }
-            if (hasMedia && mediaContent)
-                return mediaContent;
-            const result = {
-                msgtype: "text",
-                text: { content: textParts.join("") },
-            };
-            if (atUserIds.length > 0) {
-                result.at = { atUserIds, isAtAll: false };
-            }
-            return result;
-        }
-        return { msgtype: "text", text: { content: String(content) } };
-    }
-    async $connect() {
-        try {
-            await this.refreshAccessToken();
-            this.$connected = true;
-            this.logger.info(formatCompact({ endpoint: this.$config.name }));
-            this.logger.info(formatCompact({ op: "webhook", path: this.$config.webhookPath }));
-        }
-        catch (error) {
-            this.logger.error("Failed to connect DingTalk bot:", error);
-            throw error;
-        }
-    }
-    async $disconnect() {
-        try {
-            this.sessionWebhooks.clear();
-            this.$connected = false;
-            this.logger.info(formatCompact({ op: "disconnect", endpoint: this.$config.name }));
-        }
-        catch (error) {
-            this.logger.error("Error disconnecting DingTalk bot:", error);
-        }
-    }
     async getUserInfo(userId) {
         try {
-            const data = await this.request("/topapi/v2/user/get", {
-                method: "POST",
+            const data = await this.#request('/topapi/v2/user/get', {
+                method: 'POST',
                 body: { userid: userId },
             });
             if (data.errcode === 0)
@@ -420,50 +143,50 @@ export class DingTalkEndpoint {
             throw new Error(`Failed to get user info: ${data.errmsg}`);
         }
         catch (error) {
-            this.logger.error("Failed to get user info:", error);
+            logger.error('Failed to get user info:', error);
             return null;
         }
     }
     async getDepartmentUsers(deptId) {
         try {
-            const data = await this.request("/topapi/user/listid", {
-                method: "POST",
+            const data = await this.#request('/topapi/user/listid', {
+                method: 'POST',
                 body: { dept_id: deptId },
             });
-            if (data.errcode === 0)
-                return data.result.userid_list || [];
+            if (data.errcode === 0) {
+                const result = data.result;
+                return result?.userid_list || [];
+            }
             throw new Error(`Failed to get department users: ${data.errmsg}`);
         }
         catch (error) {
-            this.logger.error("Failed to get department users:", error);
+            logger.error('Failed to get department users:', error);
             return [];
         }
     }
     async sendWorkNotice(userIdList, content) {
         try {
-            const data = await this.request("/topapi/message/corpconversation/asyncsend_v2", {
-                method: "POST",
+            const data = await this.#request('/topapi/message/corpconversation/asyncsend_v2', {
+                method: 'POST',
                 body: {
-                    agent_id: this.$config.robotCode,
-                    userid_list: userIdList.join(","),
+                    agent_id: this.#options.config.robotCode,
+                    userid_list: userIdList.join(','),
                     msg: content,
                 },
             });
-            if (data.errcode === 0) {
-                this.logger.debug("Work notice sent successfully");
+            if (data.errcode === 0)
                 return true;
-            }
             throw new Error(`Failed to send work notice: ${data.errmsg}`);
         }
         catch (error) {
-            this.logger.error("Failed to send work notice:", error);
+            logger.error('Failed to send work notice:', error);
             return false;
         }
     }
     async getDepartmentList(deptId = 1) {
         try {
-            const data = await this.request("/topapi/v2/department/listsub", {
-                method: "POST",
+            const data = await this.#request('/topapi/v2/department/listsub', {
+                method: 'POST',
                 body: { dept_id: deptId },
             });
             if (data.errcode === 0)
@@ -471,14 +194,14 @@ export class DingTalkEndpoint {
             throw new Error(`Failed to get department list: ${data.errmsg}`);
         }
         catch (error) {
-            this.logger.error("Failed to get department list:", error);
+            logger.error('Failed to get department list:', error);
             return [];
         }
     }
     async getDepartmentInfo(deptId) {
         try {
-            const data = await this.request("/topapi/v2/department/get", {
-                method: "POST",
+            const data = await this.#request('/topapi/v2/department/get', {
+                method: 'POST',
                 body: { dept_id: deptId },
             });
             if (data.errcode === 0)
@@ -486,35 +209,29 @@ export class DingTalkEndpoint {
             throw new Error(`Failed to get department info: ${data.errmsg}`);
         }
         catch (error) {
-            this.logger.error("Failed to get department info:", error);
+            logger.error('Failed to get department info:', error);
             return null;
         }
     }
     async createChat(name, ownerUserId, userIdList) {
         try {
-            const data = await this.request("/topapi/chat/create", {
-                method: "POST",
-                body: {
-                    name,
-                    owner: ownerUserId,
-                    useridlist: userIdList,
-                },
+            const data = await this.#request('/topapi/chat/create', {
+                method: 'POST',
+                body: { name, owner: ownerUserId, useridlist: userIdList },
             });
-            if (data.errcode === 0) {
-                this.logger.debug(formatCompact({ op: "create_chat", chat: data.chatid }));
-                return data.chatid;
-            }
+            if (data.errcode === 0)
+                return data.chatid || null;
             throw new Error(`Failed to create chat: ${data.errmsg}`);
         }
         catch (error) {
-            this.logger.error("Failed to create chat:", error);
+            logger.error('Failed to create chat:', error);
             return null;
         }
     }
     async getChatInfo(chatId) {
         try {
-            const data = await this.request("/topapi/chat/get", {
-                method: "POST",
+            const data = await this.#request('/topapi/chat/get', {
+                method: 'POST',
                 body: { chatid: chatId },
             });
             if (data.errcode === 0)
@@ -522,26 +239,74 @@ export class DingTalkEndpoint {
             throw new Error(`Failed to get chat info: ${data.errmsg}`);
         }
         catch (error) {
-            this.logger.error("Failed to get chat info:", error);
+            logger.error('Failed to get chat info:', error);
             return null;
         }
     }
     async updateChat(chatId, options) {
         try {
-            const data = await this.request("/topapi/chat/update", {
-                method: "POST",
+            const data = await this.#request('/topapi/chat/update', {
+                method: 'POST',
                 body: { chatid: chatId, ...options },
             });
-            if (data.errcode === 0) {
-                this.logger.debug(formatCompact({ op: "update_chat", chat: chatId }));
+            if (data.errcode === 0)
                 return true;
-            }
             throw new Error(`Failed to update chat: ${data.errmsg}`);
         }
         catch (error) {
-            this.logger.error("Failed to update chat:", error);
+            logger.error('Failed to update chat:', error);
             return false;
         }
     }
+    async #request(path, options = {}) {
+        await this.#ensureAccessToken();
+        const { method = 'GET', params = {}, body } = options;
+        const urlParams = new URLSearchParams({
+            ...Object.fromEntries(Object.entries(params).map(([key, value]) => [key, String(value)])),
+            access_token: this.#accessToken.token,
+        });
+        const url = `${this.#options.config.apiBaseUrl}${path}?${urlParams.toString()}`;
+        const response = await this.#fetch(url, {
+            method,
+            headers: { 'Content-Type': 'application/json; charset=utf-8' },
+            body: body && method === 'POST' ? JSON.stringify(body) : undefined,
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            throw new Error(`DingTalk API error ${response.status}: ${text}`);
+        }
+        return await response.json();
+    }
+    async #ensureAccessToken() {
+        const now = Date.now();
+        if (this.#accessToken.token
+            && now < this.#accessToken.timestamp + (this.#accessToken.expires_in - 300) * 1000) {
+            return;
+        }
+        if (this.#refreshPromise) {
+            await this.#refreshPromise;
+            return;
+        }
+        this.#refreshPromise = this.#refreshAccessToken()
+            .then(() => this.#accessToken.token)
+            .finally(() => { this.#refreshPromise = null; });
+        await this.#refreshPromise;
+    }
+    async #refreshAccessToken() {
+        const { appKey, appSecret, apiBaseUrl } = this.#options.config;
+        const params = new URLSearchParams({ appkey: appKey, appsecret: appSecret });
+        const url = `${apiBaseUrl}/gettoken?${params.toString()}`;
+        const response = await this.#fetch(url);
+        const data = await response.json();
+        if (data.errcode === 0 && data.access_token) {
+            this.#accessToken = {
+                token: data.access_token,
+                expires_in: data.expires_in ?? 7200,
+                timestamp: Date.now(),
+            };
+            logger.debug('Access token refreshed successfully');
+            return;
+        }
+        throw new Error(`Failed to get access token: ${data.errmsg} (${data.errcode})`);
+    }
 }
-//# sourceMappingURL=endpoint.js.map