@zhin.js/adapter-discord 1.0.1

package/lib/index.js

@@ -0,0 +1,870 @@
+import { Client, GatewayIntentBits, EmbedBuilder, AttachmentBuilder, ChannelType, REST, Routes, InteractionType, InteractionResponseType } from 'discord.js';
+import { Adapter, registerAdapter, Message, segment, useContext } from "zhin.js";
+import { createReadStream } from 'fs';
+import { promises as fs } from 'fs';
+import path from 'path';
+// 主要的 DiscordBot 类
+export class DiscordBot extends Client {
+    plugin;
+    $config;
+    $connected;
+    slashCommandHandlers = new Map();
+    constructor(plugin, $config) {
+        const intents = $config.intents || [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.MessageContent,
+            GatewayIntentBits.DirectMessages,
+            GatewayIntentBits.GuildMembers,
+            GatewayIntentBits.GuildMessageReactions
+        ];
+        super({ intents });
+        this.plugin = plugin;
+        this.$config = $config;
+        this.$connected = false;
+    }
+    async handleDiscordMessage(msg) {
+        // 忽略机器人消息
+        if (msg.author.bot)
+            return;
+        const message = this.$formatMessage(msg);
+        this.plugin.dispatch('message.receive', message);
+        this.plugin.logger.info(`recv ${message.$channel.type}(${message.$channel.id}): ${segment.raw(message.$content)}`);
+        this.plugin.dispatch(`message.${message.$channel.type}.receive`, message);
+    }
+    async handleSlashCommand(interaction) {
+        const commandName = interaction.commandName;
+        const handler = this.slashCommandHandlers.get(commandName);
+        if (handler) {
+            try {
+                await handler(interaction);
+                this.plugin.logger.info(`Executed slash command: /${commandName} by ${interaction.user.tag}`);
+            }
+            catch (error) {
+                this.plugin.logger.error(`Error executing slash command /${commandName}:`, error);
+                const errorMessage = 'An error occurred while executing this command.';
+                if (interaction.replied || interaction.deferred) {
+                    await interaction.followUp({ content: errorMessage, ephemeral: true });
+                }
+                else {
+                    await interaction.reply({ content: errorMessage, ephemeral: true });
+                }
+            }
+        }
+        else {
+            this.plugin.logger.warn(`Unknown slash command: /${commandName}`);
+            if (!interaction.replied) {
+                await interaction.reply({
+                    content: 'Unknown command.',
+                    ephemeral: true
+                });
+            }
+        }
+    }
+    async $connect() {
+        return new Promise((resolve, reject) => {
+            // 监听消息事件
+            this.on('messageCreate', this.handleDiscordMessage.bind(this));
+            // 监听交互事件（Slash Commands）
+            if (this.$config.enableSlashCommands) {
+                this.on('interactionCreate', async (interaction) => {
+                    if (interaction.isChatInputCommand()) {
+                        await this.handleSlashCommand(interaction);
+                    }
+                });
+            }
+            // 监听就绪事件
+            this.once('ready', async () => {
+                this.$connected = true;
+                this.plugin.logger.info(`Discord bot ${this.$config.name} connected successfully as ${this.user?.tag}`);
+                // 设置活动状态
+                if (this.$config.defaultActivity) {
+                    this.user?.setActivity(this.$config.defaultActivity.name, {
+                        type: this.getActivityType(this.$config.defaultActivity.type),
+                        url: this.$config.defaultActivity.url
+                    });
+                }
+                // 注册 Slash Commands
+                if (this.$config.enableSlashCommands && this.$config.slashCommands) {
+                    await this.registerSlashCommands();
+                }
+                resolve();
+            });
+            // 监听错误事件
+            this.on('error', (error) => {
+                this.plugin.logger.error('Discord client error:', error);
+                this.$connected = false;
+                reject(error);
+            });
+            // 登录
+            this.login(this.$config.token).catch((error) => {
+                this.plugin.logger.error('Failed to login to Discord:', error);
+                this.$connected = false;
+                reject(error);
+            });
+        });
+    }
+    async $disconnect() {
+        try {
+            await this.destroy();
+            this.$connected = false;
+            this.plugin.logger.info(`Discord bot ${this.$config.name} disconnected`);
+        }
+        catch (error) {
+            this.plugin.logger.error('Error disconnecting Discord bot:', error);
+            throw error;
+        }
+    }
+    $formatMessage(msg) {
+        // 确定聊天类型和ID
+        let channelType;
+        let channelId;
+        if (msg.channel.type === ChannelType.DM) {
+            channelType = 'private';
+            channelId = msg.channel.id;
+        }
+        else if (msg.channel.type === ChannelType.GroupDM) {
+            channelType = 'group';
+            channelId = msg.channel.id;
+        }
+        else {
+            channelType = 'channel';
+            channelId = msg.channel.id;
+        }
+        // 转换消息内容为 segment 格式
+        const content = this.parseMessageContent(msg);
+        const result = Message.from(msg, {
+            $id: msg.id,
+            $adapter: 'discord',
+            $bot: this.$config.name,
+            $sender: {
+                id: msg.author.id,
+                name: msg.member?.displayName || msg.author.displayName
+            },
+            $channel: {
+                id: channelId,
+                type: channelType
+            },
+            $content: content,
+            $raw: msg.content,
+            $timestamp: msg.createdTimestamp,
+            $reply: async (content, quote) => {
+                if (!Array.isArray(content))
+                    content = [content];
+                const sendOptions = {};
+                // 处理回复消息
+                if (quote) {
+                    const replyId = typeof quote === "boolean" ? result.$id : quote;
+                    try {
+                        const replyMessage = await msg.channel.messages.fetch(replyId);
+                        sendOptions.reply = { messageReference: replyMessage };
+                    }
+                    catch (error) {
+                        this.plugin.logger.warn(`Could not find message to reply to: ${replyId}`);
+                    }
+                }
+                await this.sendContentToChannel(msg.channel, content, sendOptions);
+            }
+        });
+        return result;
+    }
+    // 解析 Discord 消息内容为 segment 格式
+    parseMessageContent(msg) {
+        const segments = [];
+        // 回复消息处理
+        if (msg.reference) {
+            segments.push({
+                type: 'reply',
+                data: {
+                    id: msg.reference.messageId,
+                    channel_id: msg.reference.channelId,
+                    guild_id: msg.reference.guildId
+                }
+            });
+        }
+        // 文本消息（包含提及、表情等）
+        if (msg.content) {
+            segments.push(...this.parseTextContent(msg.content, msg));
+        }
+        // 附件消息
+        for (const attachment of msg.attachments.values()) {
+            segments.push(...this.parseAttachment(attachment));
+        }
+        // Embed 消息
+        for (const embed of msg.embeds) {
+            segments.push({
+                type: 'embed',
+                data: {
+                    title: embed.title,
+                    description: embed.description,
+                    color: embed.color,
+                    url: embed.url,
+                    thumbnail: embed.thumbnail,
+                    image: embed.image,
+                    author: embed.author,
+                    footer: embed.footer,
+                    fields: embed.fields,
+                    timestamp: embed.timestamp
+                }
+            });
+        }
+        // 贴纸消息
+        for (const sticker of msg.stickers.values()) {
+            segments.push({
+                type: 'sticker',
+                data: {
+                    id: sticker.id,
+                    name: sticker.name,
+                    url: sticker.url,
+                    format: sticker.format,
+                    tags: sticker.tags
+                }
+            });
+        }
+        return segments.length > 0 ? segments : [{ type: 'text', data: { text: '' } }];
+    }
+    // 解析文本内容，处理提及、频道引用、角色引用等
+    parseTextContent(content, msg) {
+        const segments = [];
+        let lastIndex = 0;
+        // 匹配用户提及 <@!?用户ID>
+        const userMentionRegex = /<@!?(\d+)>/g;
+        // 匹配频道提及 <#频道ID>  
+        const channelMentionRegex = /<#(\d+)>/g;
+        // 匹配角色提及 <@&角色ID>
+        const roleMentionRegex = /<@&(\d+)>/g;
+        // 匹配自定义表情 <:名称:ID> 或 <a:名称:ID>
+        const emojiRegex = /<a?:(\w+):(\d+)>/g;
+        const allMatches = [];
+        // 收集所有匹配项
+        let match;
+        while ((match = userMentionRegex.exec(content)) !== null) {
+            allMatches.push({ match, type: 'user' });
+        }
+        while ((match = channelMentionRegex.exec(content)) !== null) {
+            allMatches.push({ match, type: 'channel' });
+        }
+        while ((match = roleMentionRegex.exec(content)) !== null) {
+            allMatches.push({ match, type: 'role' });
+        }
+        while ((match = emojiRegex.exec(content)) !== null) {
+            allMatches.push({ match, type: 'emoji' });
+        }
+        // 按位置排序
+        allMatches.sort((a, b) => a.match.index - b.match.index);
+        // 处理每个匹配项
+        for (const { match, type } of allMatches) {
+            const matchStart = match.index;
+            const matchEnd = matchStart + match[0].length;
+            // 添加匹配项前的文本
+            if (matchStart > lastIndex) {
+                const beforeText = content.slice(lastIndex, matchStart);
+                if (beforeText.trim()) {
+                    segments.push({ type: 'text', data: { text: beforeText } });
+                }
+            }
+            // 添加特殊内容段
+            switch (type) {
+                case 'user':
+                    const userId = match[1];
+                    const user = msg.mentions.users.get(userId);
+                    segments.push({
+                        type: 'at',
+                        data: {
+                            id: userId,
+                            name: user?.username || 'Unknown',
+                            text: match[0]
+                        }
+                    });
+                    break;
+                case 'channel':
+                    const channelId = match[1];
+                    const channel = msg.mentions.channels.get(channelId);
+                    segments.push({
+                        type: 'channel_mention',
+                        data: {
+                            id: channelId,
+                            name: channel?.name || 'unknown-channel',
+                            text: match[0]
+                        }
+                    });
+                    break;
+                case 'role':
+                    const roleId = match[1];
+                    const role = msg.mentions.roles.get(roleId);
+                    segments.push({
+                        type: 'role_mention',
+                        data: {
+                            id: roleId,
+                            name: role?.name || 'unknown-role',
+                            text: match[0]
+                        }
+                    });
+                    break;
+                case 'emoji':
+                    const emojiName = match[1];
+                    const emojiId = match[2];
+                    const isAnimated = match[0].startsWith('<a:');
+                    segments.push({
+                        type: 'emoji',
+                        data: {
+                            id: emojiId,
+                            name: emojiName,
+                            animated: isAnimated,
+                            url: `https://cdn.discordapp.com/emojis/${emojiId}.${isAnimated ? 'gif' : 'png'}`,
+                            text: match[0]
+                        }
+                    });
+                    break;
+            }
+            lastIndex = matchEnd;
+        }
+        // 添加最后剩余的文本
+        if (lastIndex < content.length) {
+            const remainingText = content.slice(lastIndex);
+            if (remainingText.trim()) {
+                segments.push({ type: 'text', data: { text: remainingText } });
+            }
+        }
+        return segments.length > 0 ? segments : [{ type: 'text', data: { text: content } }];
+    }
+    // 解析附件
+    parseAttachment(attachment) {
+        const segments = [];
+        if (attachment.contentType?.startsWith('image/')) {
+            segments.push({
+                type: 'image',
+                data: {
+                    id: attachment.id,
+                    name: attachment.name,
+                    url: attachment.url,
+                    proxy_url: attachment.proxyURL,
+                    size: attachment.size,
+                    width: attachment.width,
+                    height: attachment.height,
+                    content_type: attachment.contentType
+                }
+            });
+        }
+        else if (attachment.contentType?.startsWith('audio/')) {
+            segments.push({
+                type: 'audio',
+                data: {
+                    id: attachment.id,
+                    name: attachment.name,
+                    url: attachment.url,
+                    proxy_url: attachment.proxyURL,
+                    size: attachment.size,
+                    content_type: attachment.contentType
+                }
+            });
+        }
+        else if (attachment.contentType?.startsWith('video/')) {
+            segments.push({
+                type: 'video',
+                data: {
+                    id: attachment.id,
+                    name: attachment.name,
+                    url: attachment.url,
+                    proxy_url: attachment.proxyURL,
+                    size: attachment.size,
+                    width: attachment.width,
+                    height: attachment.height,
+                    content_type: attachment.contentType
+                }
+            });
+        }
+        else {
+            segments.push({
+                type: 'file',
+                data: {
+                    id: attachment.id,
+                    name: attachment.name,
+                    url: attachment.url,
+                    proxy_url: attachment.proxyURL,
+                    size: attachment.size,
+                    content_type: attachment.contentType
+                }
+            });
+        }
+        return segments;
+    }
+    async $sendMessage(options) {
+        options = await this.plugin.app.handleBeforeSend(options);
+        try {
+            const channel = await this.channels.fetch(options.id);
+            if (!channel || !channel.isTextBased()) {
+                throw new Error(`Channel ${options.id} is not a text channel`);
+            }
+            await this.sendContentToChannel(channel, options.content);
+            this.plugin.logger.info(`send ${options.type}(${options.id}): ${segment.raw(options.content)}`);
+        }
+        catch (error) {
+            this.plugin.logger.error('Failed to send Discord message:', error);
+            throw error;
+        }
+    }
+    // 发送内容到频道
+    async sendContentToChannel(channel, content, extraOptions = {}) {
+        if (!Array.isArray(content))
+            content = [content];
+        const messageOptions = { ...extraOptions };
+        let textContent = '';
+        const embeds = [];
+        const files = [];
+        for (const segment of content) {
+            if (typeof segment === 'string') {
+                textContent += segment;
+                continue;
+            }
+            const { type, data } = segment;
+            switch (type) {
+                case 'text':
+                    textContent += data.text || '';
+                    break;
+                case 'at':
+                    textContent += `<@${data.id}>`;
+                    break;
+                case 'channel_mention':
+                    textContent += `<#${data.id}>`;
+                    break;
+                case 'role_mention':
+                    textContent += `<@&${data.id}>`;
+                    break;
+                case 'emoji':
+                    textContent += data.animated ? `<a:${data.name}:${data.id}>` : `<:${data.name}:${data.id}>`;
+                    break;
+                case 'image':
+                case 'audio':
+                case 'video':
+                case 'file':
+                    await this.handleFileSegment(data, files, textContent);
+                    break;
+                case 'embed':
+                    embeds.push(this.createEmbedFromData(data));
+                    break;
+                default:
+                    // 未知类型作为文本处理
+                    textContent += data.text || `[${type}]`;
+            }
+        }
+        // 设置消息内容
+        if (textContent.trim()) {
+            messageOptions.content = textContent.trim();
+        }
+        if (embeds.length > 0) {
+            messageOptions.embeds = embeds.slice(0, 10); // Discord 限制最多10个embed
+        }
+        if (files.length > 0) {
+            messageOptions.files = files;
+        }
+        // 发送消息
+        await channel.send(messageOptions);
+    }
+    // 处理文件段
+    async handleFileSegment(data, files, textContent) {
+        if (data.file && await this.fileExists(data.file)) {
+            // 本地文件
+            files.push(new AttachmentBuilder(createReadStream(data.file), {
+                name: data.name || path.basename(data.file)
+            }));
+        }
+        else if (data.url) {
+            // URL 文件
+            files.push(new AttachmentBuilder(data.url, {
+                name: data.name || 'attachment'
+            }));
+        }
+        else if (data.buffer) {
+            // Buffer 数据
+            files.push(new AttachmentBuilder(data.buffer, {
+                name: data.name || 'attachment'
+            }));
+        }
+    }
+    // 从数据创建 Embed
+    createEmbedFromData(data) {
+        const embed = new EmbedBuilder();
+        if (data.title)
+            embed.setTitle(data.title);
+        if (data.description)
+            embed.setDescription(data.description);
+        if (data.color)
+            embed.setColor(data.color);
+        if (data.url)
+            embed.setURL(data.url);
+        if (data.thumbnail?.url)
+            embed.setThumbnail(data.thumbnail.url);
+        if (data.image?.url)
+            embed.setImage(data.image.url);
+        if (data.author)
+            embed.setAuthor(data.author);
+        if (data.footer)
+            embed.setFooter(data.footer);
+        if (data.timestamp)
+            embed.setTimestamp(new Date(data.timestamp));
+        if (data.fields && Array.isArray(data.fields)) {
+            embed.addFields(data.fields);
+        }
+        return embed;
+    }
+    // 工具方法：获取活动类型
+    getActivityType(type) {
+        const activityTypes = {
+            'PLAYING': 0,
+            'STREAMING': 1,
+            'LISTENING': 2,
+            'WATCHING': 3,
+            'COMPETING': 5
+        };
+        return activityTypes[type] || 0;
+    }
+    // 注册 Slash Commands
+    async registerSlashCommands() {
+        if (!this.$config.slashCommands || !this.user)
+            return;
+        try {
+            const rest = new REST({ version: '10' }).setToken(this.$config.token);
+            if (this.$config.globalCommands) {
+                // 注册全局命令
+                await rest.put(Routes.applicationCommands(this.user.id), { body: this.$config.slashCommands });
+                this.plugin.logger.info('Successfully registered global slash commands');
+            }
+            else {
+                // 为每个服务器注册命令
+                for (const guild of this.guilds.cache.values()) {
+                    await rest.put(Routes.applicationGuildCommands(this.user.id, guild.id), { body: this.$config.slashCommands });
+                }
+                this.plugin.logger.info('Successfully registered guild slash commands');
+            }
+        }
+        catch (error) {
+            this.plugin.logger.error('Failed to register slash commands:', error);
+        }
+    }
+    // 添加 Slash Command 处理器
+    addSlashCommandHandler(commandName, handler) {
+        this.slashCommandHandlers.set(commandName, handler);
+    }
+    // 移除 Slash Command 处理器
+    removeSlashCommandHandler(commandName) {
+        return this.slashCommandHandlers.delete(commandName);
+    }
+    // 工具方法：检查文件是否存在
+    async fileExists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // 静态方法：格式化内容为文本（用于日志显示）
+    static formatContentToText(content) {
+        if (!Array.isArray(content))
+            content = [content];
+        return content.map(segment => {
+            if (typeof segment === 'string')
+                return segment;
+            switch (segment.type) {
+                case 'text':
+                    return segment.data.text || '';
+                case 'at':
+                    return `@${segment.data.name || segment.data.id}`;
+                case 'channel_mention':
+                    return `#${segment.data.name}`;
+                case 'role_mention':
+                    return `@${segment.data.name}`;
+                case 'image':
+                    return '[图片]';
+                case 'audio':
+                    return '[音频]';
+                case 'video':
+                    return '[视频]';
+                case 'file':
+                    return '[文件]';
+                case 'embed':
+                    return '[嵌入消息]';
+                case 'emoji':
+                    return `:${segment.data.name}:`;
+                default:
+                    return `[${segment.type}]`;
+            }
+        }).join('');
+    }
+}
+// ================================================================================================
+// DiscordInteractionsBot 类（Interactions 端点模式）
+// ================================================================================================
+import * as nacl from 'tweetnacl';
+export class DiscordInteractionsBot extends Client {
+    plugin;
+    $config;
+    $connected;
+    router;
+    slashCommandHandlers = new Map();
+    constructor(plugin, router, $config) {
+        const intents = $config.intents || [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.MessageContent,
+        ];
+        super({ intents });
+        this.plugin = plugin;
+        this.$config = $config;
+        this.$connected = false;
+        this.router = router;
+        // 设置交互端点路由
+        this.setupInteractionsEndpoint();
+    }
+    setupInteractionsEndpoint() {
+        // 设置路由处理 Discord Interactions
+        this.router.post(this.$config.interactionsPath, (ctx) => {
+            this.handleInteraction(ctx);
+        });
+    }
+    async handleInteraction(ctx) {
+        try {
+            const signature = ctx.get('x-signature-ed25519');
+            const timestamp = ctx.get('x-signature-timestamp');
+            const bodyString = JSON.stringify(ctx.request.body);
+            // 验证请求签名
+            if (!this.verifyDiscordSignature(bodyString, signature, timestamp)) {
+                this.plugin.logger.warn('Invalid Discord signature');
+                ctx.status = 401;
+                ctx.body = 'Unauthorized';
+                return;
+            }
+            const interaction = ctx.request.body;
+            // 处理不同类型的交互
+            if (interaction.type === InteractionType.Ping) {
+                // PING - Discord 验证端点
+                ctx.body = { type: InteractionResponseType.Pong };
+            }
+            else if (interaction.type === InteractionType.ApplicationCommand) {
+                // APPLICATION_COMMAND - 应用命令
+                const response = await this.handleApplicationCommand(interaction);
+                ctx.body = response;
+            }
+            else {
+                // 其他交互类型
+                ctx.status = 400;
+                ctx.body = 'Unsupported interaction type';
+            }
+        }
+        catch (error) {
+            this.plugin.logger.error('Interactions error:', error);
+            ctx.status = 500;
+            ctx.body = 'Internal Server Error';
+        }
+    }
+    verifyDiscordSignature(body, signature, timestamp) {
+        try {
+            const publicKey = Buffer.from(this.$config.publicKey, 'hex');
+            const sig = Buffer.from(signature, 'hex');
+            const message = Buffer.from(timestamp + body, 'utf8');
+            return nacl.sign.detached.verify(message, sig, publicKey);
+        }
+        catch (error) {
+            this.plugin.logger.error('Signature verification error:', error);
+            return false;
+        }
+    }
+    async handleApplicationCommand(interaction) {
+        // 处理应用命令
+        const commandName = interaction.data.name;
+        // 转换为标准消息格式并分发
+        const message = this.formatInteractionAsMessage(interaction);
+        this.plugin.dispatch('message.receive', message);
+        // 查找自定义处理器
+        const handler = this.slashCommandHandlers.get(commandName);
+        if (handler) {
+            try {
+                await handler(interaction);
+            }
+            catch (error) {
+                this.plugin.logger.error(`Error in slash command handler for ${commandName}:`, error);
+            }
+        }
+        // 默认响应
+        return {
+            type: InteractionResponseType.ChannelMessageWithSource,
+            data: {
+                content: `处理命令: ${commandName}`,
+                flags: 64 // EPHEMERAL - 只有用户可见
+            }
+        };
+    }
+    formatInteractionAsMessage(interaction) {
+        const channelType = interaction.guild_id ? 'channel' : 'private';
+        const channelId = interaction.channel_id;
+        // 解析命令参数为内容
+        const options = interaction.data.options || [];
+        const content = [segment.text(`/${interaction.data.name}`)];
+        for (const option of options) {
+            content.push(segment.text(` ${option.name}:${option.value}`));
+        }
+        return Message.from(interaction, {
+            $id: interaction.id,
+            $adapter: 'discord-interactions',
+            $bot: this.$config.name,
+            $sender: {
+                id: interaction.user?.id || interaction.member?.user?.id,
+                name: interaction.user?.username || interaction.member?.user?.username
+            },
+            $channel: {
+                id: channelId,
+                type: channelType
+            },
+            $raw: JSON.stringify(interaction),
+            $timestamp: Date.now(),
+            $content: content,
+            $reply: async (content) => {
+                // 通过 REST API 发送后续消息
+                await this.sendFollowUp(interaction, content);
+            }
+        });
+    }
+    async sendFollowUp(interaction, content) {
+        try {
+            const rest = new REST({ version: '10' }).setToken(this.$config.token);
+            const messageContent = this.formatSendContent(content);
+            await rest.post(`/webhooks/${this.$config.applicationId}/${interaction.token}`, { body: messageContent });
+        }
+        catch (error) {
+            this.plugin.logger.error('Failed to send follow-up message:', error);
+        }
+    }
+    formatSendContent(content) {
+        if (typeof content === 'string') {
+            return { content };
+        }
+        if (Array.isArray(content)) {
+            const textParts = [];
+            let embed = null;
+            for (const item of content) {
+                if (typeof item === 'string') {
+                    textParts.push(item);
+                }
+                else {
+                    const segment = item;
+                    switch (segment.type) {
+                        case 'text':
+                            textParts.push(segment.data.text || segment.data.content || '');
+                            break;
+                        case 'embed':
+                            embed = segment.data;
+                            break;
+                    }
+                }
+            }
+            const result = {};
+            if (textParts.length > 0) {
+                result.content = textParts.join('');
+            }
+            if (embed) {
+                result.embeds = [embed];
+            }
+            return result;
+        }
+        return { content: String(content) };
+    }
+    async $connect() {
+        try {
+            // 注册 Slash Commands
+            if (this.$config.slashCommands) {
+                await this.registerSlashCommands();
+            }
+            // 如果启用 Gateway，连接 Discord Gateway
+            if (this.$config.useGateway) {
+                await this.login(this.$config.token);
+                // 设置活动状态
+                if (this.$config.defaultActivity) {
+                    this.user?.setActivity(this.$config.defaultActivity.name, {
+                        type: this.getActivityType(this.$config.defaultActivity.type),
+                        url: this.$config.defaultActivity.url
+                    });
+                }
+            }
+            this.$connected = true;
+            this.plugin.logger.info(`Discord interactions bot connected: ${this.$config.name}`);
+            this.plugin.logger.info(`Interactions endpoint: ${this.$config.interactionsPath}`);
+        }
+        catch (error) {
+            this.plugin.logger.error('Failed to connect Discord interactions bot:', error);
+            throw error;
+        }
+    }
+    async $disconnect() {
+        try {
+            if (this.isReady()) {
+                await this.destroy();
+            }
+            this.$connected = false;
+            this.plugin.logger.info('Discord interactions bot disconnected');
+        }
+        catch (error) {
+            this.plugin.logger.error('Error disconnecting Discord interactions bot:', error);
+        }
+    }
+    // Slash Commands 管理
+    async registerSlashCommands() {
+        if (!this.$config.slashCommands)
+            return;
+        try {
+            const rest = new REST({ version: '10' }).setToken(this.$config.token);
+            if (this.$config.globalCommands) {
+                await rest.put(Routes.applicationCommands(this.$config.applicationId), { body: this.$config.slashCommands });
+                this.plugin.logger.info('Successfully registered global slash commands');
+            }
+            else {
+                this.plugin.logger.info('Note: Guild commands registration requires connecting to Gateway first');
+            }
+        }
+        catch (error) {
+            this.plugin.logger.error('Failed to register slash commands:', error);
+        }
+    }
+    // 添加 Slash Command 处理器
+    addSlashCommandHandler(commandName, handler) {
+        this.slashCommandHandlers.set(commandName, handler);
+    }
+    // 移除 Slash Command 处理器
+    removeSlashCommandHandler(commandName) {
+        return this.slashCommandHandlers.delete(commandName);
+    }
+    // 工具方法
+    getActivityType(type) {
+        const activityTypes = {
+            'PLAYING': 0,
+            'STREAMING': 1,
+            'LISTENING': 2,
+            'WATCHING': 3,
+            'COMPETING': 5
+        };
+        return activityTypes[type] || 0;
+    }
+    // 简化实现 - 只支持基本消息格式化和发送
+    $formatMessage(msg) {
+        return this.formatInteractionAsMessage(msg);
+    }
+    async $sendMessage(options) {
+        // 简化实现 - 通过 REST API 发送消息
+        try {
+            const rest = new REST({ version: '10' }).setToken(this.$config.token);
+            const messageContent = this.formatSendContent(options.content);
+            await rest.post(Routes.channelMessages(options.id), { body: messageContent });
+        }
+        catch (error) {
+            this.plugin.logger.error('Failed to send message:', error);
+        }
+    }
+}
+// 注册 Gateway 模式适配器
+registerAdapter(new Adapter('discord', (plugin, config) => new DiscordBot(plugin, config)));
+// 注册 Interactions 端点模式适配器（需要 router）
+useContext('router', (router) => {
+    registerAdapter(new Adapter('discord-interactions', (plugin, config) => new DiscordInteractionsBot(plugin, router, config)));
+});
+//# sourceMappingURL=index.js.map