@zhin.js/adapter-dingtalk 1.0.81 → 1.1.2

package/lib/endpoint.js

@@ -0,0 +1,353 @@
+import { Endpoint } from 'zhin.js/adapter';
+import { formatCompact, getAdapterLogger } from '@zhin.js/logger';
+import { normalizeDingtalkSenderForPermit } from './platform-permit.js';
+import { dingtalkInboundConversation, formatInboundContent, formatOutboundBody, generateMessageId, isDingtalkBotMentioned, resolveChatType, resolveSender, } from './protocol.js';
+import { registerDingTalkWebhookRoutes } from './webhook.js';
+/** SDK-like DingTalk OpenAPI surface available on every Endpoint event. */
+export class DingTalkClient {
+    api;
+    constructor(api) {
+        this.api = api;
+    }
+    getUserInfo = (userId) => this.api.getUserInfo(userId);
+    getDepartmentUsers = (deptId) => this.api.getDepartmentUsers(deptId);
+    sendWorkNotice = (userIds, content) => this.api.sendWorkNotice(userIds, content);
+    getDepartmentList = (deptId) => this.api.getDepartmentList(deptId);
+    getDepartmentInfo = (deptId) => this.api.getDepartmentInfo(deptId);
+    createChat = (name, owner, users) => this.api.createChat(name, owner, users);
+    getChatInfo = (chatId) => this.api.getChatInfo(chatId);
+    updateChat = (chatId, options) => this.api.updateChat(chatId, options);
+}
+/**
+ * 钉钉机器人（webhook/stream 模式）无常规群列表 API——机器人不持有
+ * 「我所在的群」枚举面，仅能收发消息；
+ * 因此本 endpoint 不暴露 EndpointManagement（Console 社交面 RPC 对该平台保持未接线）。
+ */
+export class DingTalkEndpoint extends Endpoint {
+    client = new DingTalkClient({
+        getUserInfo: (userId) => this.#getUserInfo(userId),
+        getDepartmentUsers: (deptId) => this.#getDepartmentUsers(deptId),
+        sendWorkNotice: (userIds, content) => this.#sendWorkNotice(userIds, content),
+        getDepartmentList: (deptId) => this.#getDepartmentList(deptId),
+        getDepartmentInfo: (deptId) => this.#getDepartmentInfo(deptId),
+        createChat: (name, owner, users) => this.#createChat(name, owner, users),
+        getChatInfo: (chatId) => this.#getChatInfo(chatId),
+        updateChat: (chatId, options) => this.#updateChat(chatId, options),
+    });
+    #logger;
+    #options;
+    #fetch;
+    #routeReleases = [];
+    #accessToken = { token: '', expires_in: 0, timestamp: 0 };
+    #refreshPromise = null;
+    #sessionWebhooks = new Map();
+    #open = false;
+    #started = false;
+    constructor(options) {
+        super();
+        this.#logger = getAdapterLogger('dingtalk', options.config.id);
+        this.#options = options;
+        this.#fetch = options.fetch ?? globalThis.fetch;
+    }
+    /** Used by webhook handler. */
+    get isOpen() {
+        return this.#open;
+    }
+    get config() {
+        return this.#options.config;
+    }
+    async start() {
+        if (this.#started)
+            return;
+        this.#started = true;
+        try {
+            await this.#refreshAccessToken();
+            this.#routeReleases.push(...registerDingTalkWebhookRoutes(this.#options.http, this));
+            this.#logger.debug(formatCompact({
+                endpoint: this.#options.config.id,
+                op: 'webhook',
+                path: this.#options.config.webhookPath,
+            }));
+        }
+        catch (error) {
+            await this.stop();
+            this.#logger.error('Failed to connect DingTalk endpoint:', error);
+            throw error;
+        }
+    }
+    open() {
+        this.#open = true;
+    }
+    close() {
+        this.#open = false;
+    }
+    async stop() {
+        this.#open = false;
+        this.#sessionWebhooks.clear();
+        for (const release of this.#routeReleases.splice(0))
+            release();
+        this.#started = false;
+        this.#logger.debug(formatCompact({ op: 'disconnect' }));
+    }
+    async send({ conversation, payload }) {
+        const content = formatOutboundBody(payload);
+        const sessionWebhook = this.#sessionWebhooks.get(conversation.id);
+        if (sessionWebhook) {
+            const response = await this.#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(formatCompact({
+                op: 'send',
+                endpoint: this.#options.config.id,
+                via: 'sessionWebhook',
+                to: conversation.id,
+            }));
+            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}`);
+        }
+        this.#logger.debug(formatCompact({ op: 'send', to: conversation.id }));
+        return data.msgId || `${Date.now()}`;
+    }
+    /** Test / internal: admit a parsed event when open (non-webhook path). */
+    admit(event) {
+        if (!this.#open)
+            return;
+        this.#emitPlatformEvent(event.msgtype || 'event', event);
+        if (event.sessionWebhook && event.conversationId) {
+            this.#sessionWebhooks.set(event.conversationId, event.sessionWebhook);
+        }
+        const conversation = dingtalkInboundConversation(String(this.#options.id), event);
+        const chatType = resolveChatType(event.conversationType);
+        const permit = normalizeDingtalkSenderForPermit({ isAdmin: event.isAdmin === true });
+        void this.emit('message.receive', {
+            conversation,
+            message: { conversation, id: generateMessageId(event) },
+            content: formatInboundContent(event),
+            sender: {
+                id: resolveSender(event),
+                name: event.senderNick || undefined,
+                ...(permit.role ? { roles: [permit.role] } : {}),
+            },
+            endpointId: this.#options.config.id,
+            ...(isDingtalkBotMentioned(event, this.#options.config.robotCode) ? { mentioned: true } : {}),
+            metadata: Object.freeze({
+                msgtype: event.msgtype,
+                chatType,
+                senderNick: event.senderNick,
+                role: permit.role,
+                permissions: permit.permissions,
+                conversationType: event.conversationType,
+            }),
+        }).catch((err) => {
+            this.#logger.warn(formatCompact({
+                op: 'dingtalk_gateway_receive_failed',
+                conversationId: conversation.id,
+                error: err instanceof Error ? err.message : String(err),
+            }));
+        });
+    }
+    #emitPlatformEvent(name, event) {
+        void this.emitPlatform(name, event).catch((error) => {
+            this.#logger.warn(formatCompact({
+                op: 'dingtalk_platform_event_failed',
+                event: name,
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        });
+    }
+    async #getUserInfo(userId) {
+        try {
+            const data = await this.#request('/topapi/v2/user/get', {
+                method: 'POST',
+                body: { userid: userId },
+            });
+            if (data.errcode === 0)
+                return data.result;
+            throw new Error(`Failed to get user info: ${data.errmsg}`);
+        }
+        catch (error) {
+            this.#logger.error('Failed to get user info:', error);
+            return null;
+        }
+    }
+    async #getDepartmentUsers(deptId) {
+        try {
+            const data = await this.#request('/topapi/user/listid', {
+                method: 'POST',
+                body: { dept_id: deptId },
+            });
+            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);
+            return [];
+        }
+    }
+    async #sendWorkNotice(userIdList, content) {
+        try {
+            const data = await this.#request('/topapi/message/corpconversation/asyncsend_v2', {
+                method: 'POST',
+                body: {
+                    agent_id: this.#options.config.robotCode,
+                    userid_list: userIdList.join(','),
+                    msg: content,
+                },
+            });
+            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);
+            return false;
+        }
+    }
+    async #getDepartmentList(deptId = 1) {
+        try {
+            const data = await this.#request('/topapi/v2/department/listsub', {
+                method: 'POST',
+                body: { dept_id: deptId },
+            });
+            if (data.errcode === 0)
+                return data.result || [];
+            throw new Error(`Failed to get department list: ${data.errmsg}`);
+        }
+        catch (error) {
+            this.#logger.error('Failed to get department list:', error);
+            return [];
+        }
+    }
+    async #getDepartmentInfo(deptId) {
+        try {
+            const data = await this.#request('/topapi/v2/department/get', {
+                method: 'POST',
+                body: { dept_id: deptId },
+            });
+            if (data.errcode === 0)
+                return data.result;
+            throw new Error(`Failed to get department info: ${data.errmsg}`);
+        }
+        catch (error) {
+            this.#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 },
+            });
+            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);
+            return null;
+        }
+    }
+    async #getChatInfo(chatId) {
+        try {
+            const data = await this.#request('/topapi/chat/get', {
+                method: 'POST',
+                body: { chatid: chatId },
+            });
+            if (data.errcode === 0)
+                return data.chat_info;
+            throw new Error(`Failed to get chat info: ${data.errmsg}`);
+        }
+        catch (error) {
+            this.#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',
+                body: { chatid: chatId, ...options },
+            });
+            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);
+            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(),
+            };
+            this.#logger.debug('Access token refreshed successfully');
+            return;
+        }
+        throw new Error(`Failed to get access token: ${data.errmsg} (${data.errcode})`);
+    }
+}

package/lib/index.d.ts

@@ -1,15 +1,5 @@
-import { DingTalkAdapter } from "./adapter.js";
-declare module "zhin.js" {
-    namespace Plugin {
-        interface Contexts {
-            router: import("@zhin.js/host-router").Router;
-        }
-    }
-    interface Adapters {
-        dingtalk: DingTalkAdapter;
-    }
-}
-export * from "./types.js";
-export { DingTalkBot } from "./bot.js";
-export { DingTalkAdapter } from "./adapter.js";
-//# sourceMappingURL=index.d.ts.map
+export { dingtalkInboundConversation, formatInboundContent, formatOutboundBody, generateMessageId, headerValue, normalizeWebhookPath, readTextBody, resolveChatType, resolveDingTalkConfig, resolveSender, verifySignature, type AccessToken, type DingTalkEndpointConfig, type DingTalkApiResponse, type DingTalkEvent, type DingTalkMessage, type DingTalkSendBody, type DingTalkWireSegment, type ResolvedDingTalkConfig, } from './protocol.js';
+export { DingTalkClient, DingTalkEndpoint, type DingTalkClientApi, type DingTalkEndpointOptions, type DingTalkFetch, } from './endpoint.js';
+export { registerDingTalkWebhookRoutes, handleDingTalkWebhookRequest, type DingTalkWebhookHandler, } from './webhook.js';
+export { dingtalkClient, type DingtalkClientEventMap } from './client.js';
+export { checkDingtalkPlatformPermit, dingtalkGroupPermitResolver, normalizeDingtalkSenderForPermit, platformPermit, } from './platform-permit.js';

package/lib/index.js

@@ -1,214 +1,5 @@
-/**
- * 钉钉适配器入口：类型扩展、导出、注册
- */
-import { usePlugin, createGroupManagementTools } from "zhin.js";
-import { DingTalkAdapter } from "./adapter.js";
-export * from "./types.js";
-export { DingTalkBot } from "./bot.js";
-export { DingTalkAdapter } from "./adapter.js";
-const plugin = usePlugin();
-const { provide, useContext } = plugin;
-useContext("router", (router) => {
-    provide({
-        name: "dingtalk",
-        description: "DingTalk Bot Adapter",
-        mounted: async (p) => {
-            const adapter = new DingTalkAdapter(p, router);
-            await adapter.start();
-            return adapter;
-        },
-        dispose: async (adapter) => {
-            await adapter.stop();
-        },
-    });
-});
-useContext('tool', 'dingtalk', (toolService, dingtalk) => {
-    const groupTools = createGroupManagementTools(dingtalk, 'dingtalk');
-    const disposers = groupTools.map(t => toolService.addTool(t, plugin.name));
-    disposers.push(toolService.addTool({
-        name: 'dingtalk_get_user',
-        description: '获取钉钉用户信息',
-        parameters: {
-            type: 'object',
-            properties: {
-                bot: { type: 'string', description: 'Bot 名称' },
-                user_id: { type: 'string', description: '用户 ID' },
-            },
-            required: ['bot', 'user_id'],
-        },
-        platforms: ['dingtalk'],
-        tags: ['dingtalk'],
-        execute: async (args) => {
-            const bot = dingtalk.bots.get(args.bot);
-            if (!bot)
-                throw new Error(`Bot ${args.bot} 不存在`);
-            return await bot.getUserInfo(args.user_id);
-        },
-    }, plugin.name));
-    disposers.push(toolService.addTool({
-        name: 'dingtalk_get_dept_users',
-        description: '获取钉钉部门用户列表',
-        parameters: {
-            type: 'object',
-            properties: {
-                bot: { type: 'string', description: 'Bot 名称' },
-                dept_id: { type: 'string', description: '部门 ID' },
-            },
-            required: ['bot', 'dept_id'],
-        },
-        platforms: ['dingtalk'],
-        tags: ['dingtalk'],
-        execute: async (args) => {
-            const bot = dingtalk.bots.get(args.bot);
-            if (!bot)
-                throw new Error(`Bot ${args.bot} 不存在`);
-            const users = await bot.getDepartmentUsers(args.dept_id);
-            return { users, count: users.length };
-        },
-    }, plugin.name));
-    disposers.push(toolService.addTool({
-        name: 'dingtalk_list_departments',
-        description: '获取钉钉部门列表',
-        parameters: {
-            type: 'object',
-            properties: {
-                bot: { type: 'string', description: 'Bot 名称' },
-                dept_id: { type: 'string', description: '父部门 ID，默认 1（根部门）' },
-            },
-            required: ['bot'],
-        },
-        platforms: ['dingtalk'],
-        tags: ['dingtalk'],
-        execute: async (args) => {
-            const bot = dingtalk.bots.get(args.bot);
-            if (!bot)
-                throw new Error(`Bot ${args.bot} 不存在`);
-            const departments = await bot.getDepartmentList(args.dept_id || '1');
-            return { departments, count: departments.length };
-        },
-    }, plugin.name));
-    disposers.push(toolService.addTool({
-        name: 'dingtalk_send_work_notice',
-        description: '向指定用户发送钉钉工作通知',
-        parameters: {
-            type: 'object',
-            properties: {
-                bot: { type: 'string', description: 'Bot 名称' },
-                user_ids: { type: 'string', description: '用户 ID 列表，逗号分隔' },
-                content: { type: 'string', description: '通知内容' },
-            },
-            required: ['bot', 'user_ids', 'content'],
-        },
-        platforms: ['dingtalk'],
-        tags: ['dingtalk'],
-        execute: async (args) => {
-            const bot = dingtalk.bots.get(args.bot);
-            if (!bot)
-                throw new Error(`Bot ${args.bot} 不存在`);
-            const msgContent = { msgtype: 'text', text: { content: args.content } };
-            const success = await bot.sendWorkNotice(args.user_ids.split(','), msgContent);
-            return { success, message: success ? '工作通知已发送' : '发送失败' };
-        },
-    }, plugin.name));
-    disposers.push(toolService.addTool({
-        name: 'dingtalk_create_chat',
-        description: '创建钉钉群聊',
-        parameters: {
-            type: 'object',
-            properties: {
-                bot: { type: 'string', description: 'Bot 名称' },
-                name: { type: 'string', description: '群名' },
-                owner: { type: 'string', description: '群主用户 ID' },
-                members: { type: 'string', description: '成员用户 ID 列表，逗号分隔' },
-            },
-            required: ['bot', 'name', 'owner', 'members'],
-        },
-        platforms: ['dingtalk'],
-        tags: ['dingtalk'],
-        execute: async (args) => {
-            const bot = dingtalk.bots.get(args.bot);
-            if (!bot)
-                throw new Error(`Bot ${args.bot} 不存在`);
-            const chatId = await bot.createChat(args.name, args.owner, args.members.split(','));
-            return { success: !!chatId, chat_id: chatId, message: chatId ? `群聊创建成功: ${chatId}` : '创建失败' };
-        },
-    }, plugin.name));
-    disposers.push(toolService.addTool({
-        name: 'dingtalk_add_chat_members',
-        description: '向钉钉群聊添加成员',
-        parameters: {
-            type: 'object',
-            properties: {
-                bot: { type: 'string', description: 'Bot 名称' },
-                chat_id: { type: 'string', description: '群聊 ID' },
-                user_ids: { type: 'string', description: '要添加的用户 ID 列表，逗号分隔' },
-            },
-            required: ['bot', 'chat_id', 'user_ids'],
-        },
-        platforms: ['dingtalk'],
-        tags: ['dingtalk'],
-        execute: async (args) => {
-            const bot = dingtalk.bots.get(args.bot);
-            if (!bot)
-                throw new Error(`Bot ${args.bot} 不存在`);
-            const success = await bot.updateChat(args.chat_id, { add_useridlist: args.user_ids.split(',') });
-            return { success, message: success ? '成员添加成功' : '添加失败' };
-        },
-    }, plugin.name));
-    disposers.push(toolService.addTool({
-        name: 'dingtalk_dept_info',
-        description: '获取钉钉部门详细信息',
-        parameters: {
-            type: 'object',
-            properties: {
-                bot: { type: 'string', description: 'Bot 名称' },
-                dept_id: { type: 'string', description: '部门 ID' },
-            },
-            required: ['bot', 'dept_id'],
-        },
-        platforms: ['dingtalk'],
-        tags: ['dingtalk'],
-        execute: async (args) => {
-            const bot = dingtalk.bots.get(args.bot);
-            if (!bot)
-                throw new Error(`Bot ${args.bot} 不存在`);
-            return await bot.getDepartmentInfo(Number(args.dept_id));
-        },
-    }, plugin.name));
-    disposers.push(toolService.addTool({
-        name: 'dingtalk_update_chat',
-        description: '更新钉钉群聊设置（改名、换群主、增减成员）',
-        parameters: {
-            type: 'object',
-            properties: {
-                bot: { type: 'string', description: 'Bot 名称' },
-                chat_id: { type: 'string', description: '群聊 ID' },
-                name: { type: 'string', description: '新群名（可选）' },
-                owner: { type: 'string', description: '新群主 userId（可选）' },
-                add_members: { type: 'string', description: '要添加的成员 userId，逗号分隔（可选）' },
-                remove_members: { type: 'string', description: '要移除的成员 userId，逗号分隔（可选）' },
-            },
-            required: ['bot', 'chat_id'],
-        },
-        platforms: ['dingtalk'],
-        tags: ['dingtalk'],
-        execute: async (args) => {
-            const bot = dingtalk.bots.get(args.bot);
-            if (!bot)
-                throw new Error(`Bot ${args.bot} 不存在`);
-            const options = {};
-            if (args.name)
-                options.name = args.name;
-            if (args.owner)
-                options.owner = args.owner;
-            if (args.add_members)
-                options.add_useridlist = args.add_members.split(',').map((s) => s.trim());
-            if (args.remove_members)
-                options.del_useridlist = args.remove_members.split(',').map((s) => s.trim());
-            await bot.updateChat(args.chat_id, options);
-            return { success: true, message: '群聊设置已更新' };
-        },
-    }, plugin.name));
-    return () => disposers.forEach(d => d());
-});
-//# sourceMappingURL=index.js.map
+export { dingtalkInboundConversation, formatInboundContent, formatOutboundBody, generateMessageId, headerValue, normalizeWebhookPath, readTextBody, resolveChatType, resolveDingTalkConfig, resolveSender, verifySignature, } from './protocol.js';
+export { DingTalkClient, DingTalkEndpoint, } from './endpoint.js';
+export { registerDingTalkWebhookRoutes, handleDingTalkWebhookRequest, } from './webhook.js';
+export { dingtalkClient } from './client.js';
+export { checkDingtalkPlatformPermit, dingtalkGroupPermitResolver, normalizeDingtalkSenderForPermit, platformPermit, } from './platform-permit.js';

package/lib/platform-permit.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 钉钉 DingTalk platform permit
+ */
+import type { PermissionSubject } from '@zhin.js/permission';
+export declare function platformPermit(perm: string): string;
+export declare function dingtalkGroupPermitResolver(logicalPerm: string): string;
+export declare function normalizeDingtalkSenderForPermit(input: {
+    isOwner?: boolean;
+    isAdmin?: boolean;
+}): {
+    role?: string;
+    permissions?: string[];
+};
+export declare function checkDingtalkPlatformPermit(perm: string, subject: PermissionSubject): boolean;

package/lib/platform-permit.js

@@ -0,0 +1,33 @@
+const ADAPTER = 'dingtalk';
+export function platformPermit(perm) {
+    return `platform(${ADAPTER},${perm})`;
+}
+const FACTORY_PERM_MAP = {
+    scene_admin: 'chat_admin',
+    scene_owner: 'chat_owner',
+};
+export function dingtalkGroupPermitResolver(logicalPerm) {
+    return platformPermit(FACTORY_PERM_MAP[logicalPerm] ?? logicalPerm);
+}
+export function normalizeDingtalkSenderForPermit(input) {
+    if (input.isOwner) {
+        return { role: 'owner', permissions: ['chat_owner', 'chat_admin'] };
+    }
+    if (input.isAdmin) {
+        return { role: 'admin', permissions: ['chat_admin'] };
+    }
+    return { role: 'member', permissions: [] };
+}
+export function checkDingtalkPlatformPermit(perm, subject) {
+    const role = subject.sender?.role?.[0];
+    const permissions = subject.sender?.permissions ?? [];
+    const has = (t) => permissions.includes(t);
+    switch (perm) {
+        case 'chat_owner':
+            return role === 'owner' || has('chat_owner');
+        case 'chat_admin':
+            return role === 'owner' || role === 'admin' || has('chat_admin') || has('chat_owner');
+        default:
+            return false;
+    }
+}