@onebots/adapter-discord 1.0.0

package/lib/lite/index.js

@@ -0,0 +1,244 @@
+/**
+ * Discord Lite - 轻量版 Discord 客户端
+ *
+ * 特性：
+ * - 使用原生 fetch，无外部依赖
+ * - 自动检测运行时环境
+ * - Node.js: 支持 Gateway WebSocket
+ * - Cloudflare Workers / Vercel: 支持 Interactions Webhook
+ *
+ * @example Node.js Gateway 模式
+ * ```ts
+ * import { DiscordLite, GatewayIntents } from './lite';
+ *
+ * const client = new DiscordLite({
+ *   token: 'your-bot-token',
+ *   intents: GatewayIntents.Guilds | GatewayIntents.GuildMessages | GatewayIntents.MessageContent,
+ *   mode: 'gateway',
+ * });
+ *
+ * client.on('messageCreate', (message) => {
+ *   console.log(message.content);
+ * });
+ *
+ * await client.start();
+ * ```
+ *
+ * @example Cloudflare Workers Webhook 模式
+ * ```ts
+ * import { DiscordLite, InteractionsHandler } from './lite';
+ *
+ * const handler = new InteractionsHandler({
+ *   publicKey: 'your-public-key',
+ *   token: 'your-bot-token',
+ *   applicationId: 'your-app-id',
+ * });
+ *
+ * handler.onCommand('hello', async (interaction) => {
+ *   return InteractionsHandler.messageResponse('Hello, World!');
+ * });
+ *
+ * export default {
+ *   fetch: (request) => handler.handleRequest(request),
+ * };
+ * ```
+ */
+import { EventEmitter } from 'events';
+import { DiscordREST } from './rest.js';
+import { DiscordGateway, GatewayIntents } from './gateway.js';
+import { InteractionsHandler } from './interactions.js';
+// 重新导出
+export { DiscordREST } from './rest.js';
+export { DiscordGateway, GatewayIntents, GatewayOpcodes } from './gateway.js';
+export { InteractionsHandler, InteractionType, InteractionCallbackType, verifyInteractionSignature } from './interactions.js';
+export { DiscordLiteBot } from './bot.js';
+/**
+ * 检测当前运行时环境
+ */
+export function detectRuntime() {
+    // Cloudflare Workers
+    if (typeof globalThis.caches !== 'undefined' && typeof globalThis.WebSocketPair !== 'undefined') {
+        return 'cloudflare';
+    }
+    // Vercel Edge Runtime
+    if (typeof globalThis.EdgeRuntime !== 'undefined') {
+        return 'vercel';
+    }
+    // Deno
+    if (typeof globalThis.Deno !== 'undefined') {
+        return 'deno';
+    }
+    // Bun
+    if (typeof globalThis.Bun !== 'undefined') {
+        return 'bun';
+    }
+    // Node.js
+    if (typeof process !== 'undefined' && process.versions?.node) {
+        return 'node';
+    }
+    // Browser
+    if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+        return 'browser';
+    }
+    return 'unknown';
+}
+/**
+ * 检测是否支持 WebSocket Gateway
+ */
+export function supportsGateway() {
+    const runtime = detectRuntime();
+    return ['node', 'bun', 'deno'].includes(runtime);
+}
+/**
+ * Discord Lite 统一客户端
+ */
+export class DiscordLite extends EventEmitter {
+    options;
+    gateway = null;
+    interactions = null;
+    rest;
+    runtime;
+    mode;
+    user = null;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.runtime = detectRuntime();
+        this.rest = new DiscordREST({ token: options.token, proxy: options.proxy });
+        // 确定运行模式
+        if (options.mode === 'auto' || !options.mode) {
+            this.mode = supportsGateway() ? 'gateway' : 'interactions';
+        }
+        else {
+            this.mode = options.mode;
+        }
+        console.log(`[DiscordLite] 运行时: ${this.runtime}, 模式: ${this.mode}`);
+    }
+    /**
+     * 启动客户端（Gateway 模式）
+     */
+    async start() {
+        if (this.mode !== 'gateway') {
+            throw new Error('start() 仅支持 Gateway 模式，Interactions 模式请使用 handleRequest()');
+        }
+        if (!supportsGateway()) {
+            throw new Error(`当前运行时 ${this.runtime} 不支持 Gateway 模式`);
+        }
+        const intents = this.options.intents ?? (GatewayIntents.Guilds |
+            GatewayIntents.GuildMessages |
+            GatewayIntents.DirectMessages |
+            GatewayIntents.MessageContent);
+        this.gateway = new DiscordGateway({
+            token: this.options.token,
+            intents,
+            proxy: this.options.proxy,
+        });
+        // 转发事件
+        this.gateway.on('ready', (user) => {
+            this.user = user;
+            this.emit('ready', user);
+        });
+        this.gateway.on('messageCreate', (message) => this.emit('messageCreate', message));
+        this.gateway.on('messageUpdate', (message) => this.emit('messageUpdate', message));
+        this.gateway.on('messageDelete', (data) => this.emit('messageDelete', data));
+        this.gateway.on('guildCreate', (guild) => this.emit('guildCreate', guild));
+        this.gateway.on('guildDelete', (guild) => this.emit('guildDelete', guild));
+        this.gateway.on('guildMemberAdd', (member) => this.emit('guildMemberAdd', member));
+        this.gateway.on('guildMemberRemove', (member) => this.emit('guildMemberRemove', member));
+        this.gateway.on('interactionCreate', (interaction) => this.emit('interactionCreate', interaction));
+        this.gateway.on('dispatch', (event, data) => this.emit('dispatch', event, data));
+        this.gateway.on('error', (error) => this.emit('error', error));
+        this.gateway.on('close', (code, reason) => this.emit('close', code, reason));
+        await this.gateway.connect();
+    }
+    /**
+     * 停止客户端
+     */
+    stop() {
+        if (this.gateway) {
+            this.gateway.disconnect();
+            this.gateway = null;
+        }
+    }
+    /**
+     * 初始化 Interactions 处理器
+     */
+    initInteractions() {
+        if (!this.options.publicKey || !this.options.applicationId) {
+            throw new Error('Interactions 模式需要 publicKey 和 applicationId');
+        }
+        this.interactions = new InteractionsHandler({
+            publicKey: this.options.publicKey,
+            token: this.options.token,
+            applicationId: this.options.applicationId,
+        });
+        return this.interactions;
+    }
+    /**
+     * 处理 HTTP 请求（Interactions 模式）
+     */
+    async handleRequest(request) {
+        if (!this.interactions) {
+            this.initInteractions();
+        }
+        return this.interactions.handleRequest(request);
+    }
+    /**
+     * 获取 REST 客户端
+     */
+    getREST() {
+        return this.rest;
+    }
+    /**
+     * 获取当前用户
+     */
+    getUser() {
+        return this.user;
+    }
+    /**
+     * 获取当前运行时
+     */
+    getRuntime() {
+        return this.runtime;
+    }
+    /**
+     * 获取当前模式
+     */
+    getMode() {
+        return this.mode;
+    }
+    // ============================================
+    // 便捷方法
+    // ============================================
+    /** 发送消息 */
+    async sendMessage(channelId, content) {
+        return this.rest.createMessage(channelId, content);
+    }
+    /** 编辑消息 */
+    async editMessage(channelId, messageId, content) {
+        return this.rest.editMessage(channelId, messageId, content);
+    }
+    /** 删除消息 */
+    async deleteMessage(channelId, messageId) {
+        return this.rest.deleteMessage(channelId, messageId);
+    }
+    /** 获取消息 */
+    async getMessage(channelId, messageId) {
+        return this.rest.getMessage(channelId, messageId);
+    }
+    /** 获取服务器 */
+    async getGuild(guildId) {
+        return this.rest.getGuild(guildId);
+    }
+    /** 获取服务器成员 */
+    async getGuildMember(guildId, userId) {
+        return this.rest.getGuildMember(guildId, userId);
+    }
+}
+/**
+ * 创建 Discord Lite 客户端的便捷方法
+ */
+export function createClient(options) {
+    return new DiscordLite(options);
+}
+//# sourceMappingURL=index.js.map

package/lib/lite/interactions.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Discord Interactions Webhook 处理器
+ * 用于 Cloudflare Workers / Vercel 等 Serverless 环境
+ */
+import { DiscordREST } from './rest.js';
+export declare enum InteractionType {
+    Ping = 1,
+    ApplicationCommand = 2,
+    MessageComponent = 3,
+    ApplicationCommandAutocomplete = 4,
+    ModalSubmit = 5
+}
+export declare enum InteractionCallbackType {
+    Pong = 1,
+    ChannelMessageWithSource = 4,
+    DeferredChannelMessageWithSource = 5,
+    DeferredUpdateMessage = 6,
+    UpdateMessage = 7,
+    ApplicationCommandAutocompleteResult = 8,
+    Modal = 9,
+    PremiumRequired = 10
+}
+export interface InteractionWebhookOptions {
+    publicKey: string;
+    token: string;
+    applicationId: string;
+}
+/**
+ * 验证 Discord Interaction 请求签名
+ * 使用 Web Crypto API，兼容所有运行时
+ */
+export declare function verifyInteractionSignature(publicKey: string, signature: string, timestamp: string, body: string): Promise<boolean>;
+/**
+ * Discord Interactions Webhook 处理器
+ */
+export declare class InteractionsHandler {
+    private publicKey;
+    private token;
+    private applicationId;
+    private rest;
+    private handlers;
+    constructor(options: InteractionWebhookOptions);
+    /**
+     * 注册命令处理器
+     */
+    onCommand(name: string, handler: (interaction: any) => Promise<any>): void;
+    /**
+     * 注册消息组件处理器
+     */
+    onComponent(customId: string, handler: (interaction: any) => Promise<any>): void;
+    /**
+     * 注册模态框提交处理器
+     */
+    onModalSubmit(customId: string, handler: (interaction: any) => Promise<any>): void;
+    /**
+     * 处理 HTTP 请求
+     * 适用于 Cloudflare Workers / Vercel Edge Functions
+     */
+    handleRequest(request: Request): Promise<Response>;
+    /**
+     * 处理 Interaction
+     */
+    handleInteraction(interaction: any): Promise<any>;
+    /**
+     * 默认响应
+     */
+    private defaultResponse;
+    /**
+     * 创建延迟响应
+     */
+    static deferResponse(ephemeral?: boolean): {
+        type: InteractionCallbackType;
+        data: {
+            flags: number;
+        } | {
+            flags?: undefined;
+        };
+    };
+    /**
+     * 创建消息响应
+     */
+    static messageResponse(content: string | {
+        content?: string;
+        embeds?: any[];
+        components?: any[];
+    }, ephemeral?: boolean): {
+        type: InteractionCallbackType;
+        data: {
+            flags: number;
+            content?: string;
+            embeds?: any[];
+            components?: any[];
+        };
+    };
+    /**
+     * 创建更新消息响应
+     */
+    static updateResponse(content: string | {
+        content?: string;
+        embeds?: any[];
+        components?: any[];
+    }): {
+        type: InteractionCallbackType;
+        data: {
+            content?: string;
+            embeds?: any[];
+            components?: any[];
+        };
+    };
+    /**
+     * 创建模态框响应
+     */
+    static modalResponse(customId: string, title: string, components: any[]): {
+        type: InteractionCallbackType;
+        data: {
+            custom_id: string;
+            title: string;
+            components: any[];
+        };
+    };
+    /**
+     * 获取 REST 客户端
+     */
+    getREST(): DiscordREST;
+    /**
+     * 编辑后续消息（用于延迟响应后）
+     */
+    editFollowup(interactionToken: string, content: any): Promise<any>;
+    /**
+     * 发送后续消息
+     */
+    sendFollowup(interactionToken: string, content: any): Promise<any>;
+}
+//# sourceMappingURL=interactions.d.ts.map

package/lib/lite/interactions.js

@@ -0,0 +1,238 @@
+/**
+ * Discord Interactions Webhook 处理器
+ * 用于 Cloudflare Workers / Vercel 等 Serverless 环境
+ */
+import { DiscordREST } from './rest.js';
+// Interaction Types
+export var InteractionType;
+(function (InteractionType) {
+    InteractionType[InteractionType["Ping"] = 1] = "Ping";
+    InteractionType[InteractionType["ApplicationCommand"] = 2] = "ApplicationCommand";
+    InteractionType[InteractionType["MessageComponent"] = 3] = "MessageComponent";
+    InteractionType[InteractionType["ApplicationCommandAutocomplete"] = 4] = "ApplicationCommandAutocomplete";
+    InteractionType[InteractionType["ModalSubmit"] = 5] = "ModalSubmit";
+})(InteractionType || (InteractionType = {}));
+// Interaction Callback Types
+export var InteractionCallbackType;
+(function (InteractionCallbackType) {
+    InteractionCallbackType[InteractionCallbackType["Pong"] = 1] = "Pong";
+    InteractionCallbackType[InteractionCallbackType["ChannelMessageWithSource"] = 4] = "ChannelMessageWithSource";
+    InteractionCallbackType[InteractionCallbackType["DeferredChannelMessageWithSource"] = 5] = "DeferredChannelMessageWithSource";
+    InteractionCallbackType[InteractionCallbackType["DeferredUpdateMessage"] = 6] = "DeferredUpdateMessage";
+    InteractionCallbackType[InteractionCallbackType["UpdateMessage"] = 7] = "UpdateMessage";
+    InteractionCallbackType[InteractionCallbackType["ApplicationCommandAutocompleteResult"] = 8] = "ApplicationCommandAutocompleteResult";
+    InteractionCallbackType[InteractionCallbackType["Modal"] = 9] = "Modal";
+    InteractionCallbackType[InteractionCallbackType["PremiumRequired"] = 10] = "PremiumRequired";
+})(InteractionCallbackType || (InteractionCallbackType = {}));
+/**
+ * 验证 Discord Interaction 请求签名
+ * 使用 Web Crypto API，兼容所有运行时
+ */
+export async function verifyInteractionSignature(publicKey, signature, timestamp, body) {
+    try {
+        // 将 hex 字符串转换为 Uint8Array
+        const hexToUint8Array = (hex) => {
+            const matches = hex.match(/.{1,2}/g);
+            return new Uint8Array(matches ? matches.map(byte => parseInt(byte, 16)) : []);
+        };
+        const publicKeyBytes = hexToUint8Array(publicKey);
+        const signatureBytes = hexToUint8Array(signature);
+        const messageBytes = new TextEncoder().encode(timestamp + body);
+        // 使用 Web Crypto API（兼容 Node.js 和 Cloudflare Workers）
+        const cryptoKey = await crypto.subtle.importKey('raw', publicKeyBytes, { name: 'Ed25519', namedCurve: 'Ed25519' }, false, ['verify']);
+        return await crypto.subtle.verify('Ed25519', cryptoKey, signatureBytes, messageBytes);
+    }
+    catch (error) {
+        console.error('签名验证失败:', error);
+        return false;
+    }
+}
+/**
+ * Discord Interactions Webhook 处理器
+ */
+export class InteractionsHandler {
+    publicKey;
+    token;
+    applicationId;
+    rest;
+    handlers = new Map();
+    constructor(options) {
+        this.publicKey = options.publicKey;
+        this.token = options.token;
+        this.applicationId = options.applicationId;
+        this.rest = new DiscordREST({ token: options.token });
+    }
+    /**
+     * 注册命令处理器
+     */
+    onCommand(name, handler) {
+        this.handlers.set(`command:${name}`, handler);
+    }
+    /**
+     * 注册消息组件处理器
+     */
+    onComponent(customId, handler) {
+        this.handlers.set(`component:${customId}`, handler);
+    }
+    /**
+     * 注册模态框提交处理器
+     */
+    onModalSubmit(customId, handler) {
+        this.handlers.set(`modal:${customId}`, handler);
+    }
+    /**
+     * 处理 HTTP 请求
+     * 适用于 Cloudflare Workers / Vercel Edge Functions
+     */
+    async handleRequest(request) {
+        // 验证签名
+        const signature = request.headers.get('x-signature-ed25519');
+        const timestamp = request.headers.get('x-signature-timestamp');
+        const body = await request.text();
+        if (!signature || !timestamp) {
+            return new Response('Missing signature', { status: 401 });
+        }
+        const isValid = await verifyInteractionSignature(this.publicKey, signature, timestamp, body);
+        if (!isValid) {
+            return new Response('Invalid signature', { status: 401 });
+        }
+        // 解析并处理 Interaction
+        const interaction = JSON.parse(body);
+        const response = await this.handleInteraction(interaction);
+        return new Response(JSON.stringify(response), {
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+    /**
+     * 处理 Interaction
+     */
+    async handleInteraction(interaction) {
+        const { type, data } = interaction;
+        // Ping/Pong 健康检查
+        if (type === InteractionType.Ping) {
+            return { type: InteractionCallbackType.Pong };
+        }
+        // 应用命令
+        if (type === InteractionType.ApplicationCommand) {
+            const handler = this.handlers.get(`command:${data.name}`);
+            if (handler) {
+                return handler(interaction);
+            }
+            return this.defaultResponse('命令未找到');
+        }
+        // 消息组件
+        if (type === InteractionType.MessageComponent) {
+            // 尝试精确匹配
+            let handler = this.handlers.get(`component:${data.custom_id}`);
+            // 尝试前缀匹配
+            if (!handler) {
+                for (const [key, h] of this.handlers) {
+                    if (key.startsWith('component:') && data.custom_id.startsWith(key.slice(10))) {
+                        handler = h;
+                        break;
+                    }
+                }
+            }
+            if (handler) {
+                return handler(interaction);
+            }
+            return this.defaultResponse('组件处理器未找到');
+        }
+        // 模态框提交
+        if (type === InteractionType.ModalSubmit) {
+            const handler = this.handlers.get(`modal:${data.custom_id}`);
+            if (handler) {
+                return handler(interaction);
+            }
+            return this.defaultResponse('模态框处理器未找到');
+        }
+        // 自动补全
+        if (type === InteractionType.ApplicationCommandAutocomplete) {
+            const handler = this.handlers.get(`autocomplete:${data.name}`);
+            if (handler) {
+                return handler(interaction);
+            }
+            return {
+                type: InteractionCallbackType.ApplicationCommandAutocompleteResult,
+                data: { choices: [] },
+            };
+        }
+        return this.defaultResponse('未知的 Interaction 类型');
+    }
+    /**
+     * 默认响应
+     */
+    defaultResponse(message) {
+        return {
+            type: InteractionCallbackType.ChannelMessageWithSource,
+            data: {
+                content: message,
+                flags: 64, // Ephemeral
+            },
+        };
+    }
+    /**
+     * 创建延迟响应
+     */
+    static deferResponse(ephemeral = false) {
+        return {
+            type: InteractionCallbackType.DeferredChannelMessageWithSource,
+            data: ephemeral ? { flags: 64 } : {},
+        };
+    }
+    /**
+     * 创建消息响应
+     */
+    static messageResponse(content, ephemeral = false) {
+        const data = typeof content === 'string' ? { content } : content;
+        return {
+            type: InteractionCallbackType.ChannelMessageWithSource,
+            data: {
+                ...data,
+                flags: ephemeral ? 64 : 0,
+            },
+        };
+    }
+    /**
+     * 创建更新消息响应
+     */
+    static updateResponse(content) {
+        const data = typeof content === 'string' ? { content } : content;
+        return {
+            type: InteractionCallbackType.UpdateMessage,
+            data,
+        };
+    }
+    /**
+     * 创建模态框响应
+     */
+    static modalResponse(customId, title, components) {
+        return {
+            type: InteractionCallbackType.Modal,
+            data: {
+                custom_id: customId,
+                title,
+                components,
+            },
+        };
+    }
+    /**
+     * 获取 REST 客户端
+     */
+    getREST() {
+        return this.rest;
+    }
+    /**
+     * 编辑后续消息（用于延迟响应后）
+     */
+    async editFollowup(interactionToken, content) {
+        return this.rest.editOriginalInteractionResponse(this.applicationId, interactionToken, content);
+    }
+    /**
+     * 发送后续消息
+     */
+    async sendFollowup(interactionToken, content) {
+        return this.rest.createFollowupMessage(this.applicationId, interactionToken, content);
+    }
+}
+//# sourceMappingURL=interactions.js.map