@onebots/adapter-discord 1.0.0

package/lib/lite/gateway.js

@@ -0,0 +1,349 @@
+/**
+ * Discord Gateway WebSocket 客户端
+ * 用于 Node.js 环境
+ */
+import { EventEmitter } from 'events';
+import { DiscordREST } from './rest.js';
+// Gateway Opcodes
+export var GatewayOpcodes;
+(function (GatewayOpcodes) {
+    GatewayOpcodes[GatewayOpcodes["Dispatch"] = 0] = "Dispatch";
+    GatewayOpcodes[GatewayOpcodes["Heartbeat"] = 1] = "Heartbeat";
+    GatewayOpcodes[GatewayOpcodes["Identify"] = 2] = "Identify";
+    GatewayOpcodes[GatewayOpcodes["PresenceUpdate"] = 3] = "PresenceUpdate";
+    GatewayOpcodes[GatewayOpcodes["VoiceStateUpdate"] = 4] = "VoiceStateUpdate";
+    GatewayOpcodes[GatewayOpcodes["Resume"] = 6] = "Resume";
+    GatewayOpcodes[GatewayOpcodes["Reconnect"] = 7] = "Reconnect";
+    GatewayOpcodes[GatewayOpcodes["RequestGuildMembers"] = 8] = "RequestGuildMembers";
+    GatewayOpcodes[GatewayOpcodes["InvalidSession"] = 9] = "InvalidSession";
+    GatewayOpcodes[GatewayOpcodes["Hello"] = 10] = "Hello";
+    GatewayOpcodes[GatewayOpcodes["HeartbeatAck"] = 11] = "HeartbeatAck";
+})(GatewayOpcodes || (GatewayOpcodes = {}));
+// Gateway Intents
+export var GatewayIntents;
+(function (GatewayIntents) {
+    GatewayIntents[GatewayIntents["Guilds"] = 1] = "Guilds";
+    GatewayIntents[GatewayIntents["GuildMembers"] = 2] = "GuildMembers";
+    GatewayIntents[GatewayIntents["GuildModeration"] = 4] = "GuildModeration";
+    GatewayIntents[GatewayIntents["GuildEmojisAndStickers"] = 8] = "GuildEmojisAndStickers";
+    GatewayIntents[GatewayIntents["GuildIntegrations"] = 16] = "GuildIntegrations";
+    GatewayIntents[GatewayIntents["GuildWebhooks"] = 32] = "GuildWebhooks";
+    GatewayIntents[GatewayIntents["GuildInvites"] = 64] = "GuildInvites";
+    GatewayIntents[GatewayIntents["GuildVoiceStates"] = 128] = "GuildVoiceStates";
+    GatewayIntents[GatewayIntents["GuildPresences"] = 256] = "GuildPresences";
+    GatewayIntents[GatewayIntents["GuildMessages"] = 512] = "GuildMessages";
+    GatewayIntents[GatewayIntents["GuildMessageReactions"] = 1024] = "GuildMessageReactions";
+    GatewayIntents[GatewayIntents["GuildMessageTyping"] = 2048] = "GuildMessageTyping";
+    GatewayIntents[GatewayIntents["DirectMessages"] = 4096] = "DirectMessages";
+    GatewayIntents[GatewayIntents["DirectMessageReactions"] = 8192] = "DirectMessageReactions";
+    GatewayIntents[GatewayIntents["DirectMessageTyping"] = 16384] = "DirectMessageTyping";
+    GatewayIntents[GatewayIntents["MessageContent"] = 32768] = "MessageContent";
+    GatewayIntents[GatewayIntents["GuildScheduledEvents"] = 65536] = "GuildScheduledEvents";
+    GatewayIntents[GatewayIntents["AutoModerationConfiguration"] = 1048576] = "AutoModerationConfiguration";
+    GatewayIntents[GatewayIntents["AutoModerationExecution"] = 2097152] = "AutoModerationExecution";
+})(GatewayIntents || (GatewayIntents = {}));
+export class DiscordGateway extends EventEmitter {
+    ws = null;
+    token;
+    intents;
+    proxyUrl;
+    heartbeatInterval = null;
+    sequence = null;
+    sessionId = null;
+    resumeGatewayUrl = null;
+    rest;
+    isReady = false;
+    constructor(options) {
+        super();
+        this.token = options.token;
+        this.intents = options.intents;
+        if (options.proxy?.url) {
+            const proxyUrl = new URL(options.proxy.url);
+            if (options.proxy.username)
+                proxyUrl.username = options.proxy.username;
+            if (options.proxy.password)
+                proxyUrl.password = options.proxy.password;
+            this.proxyUrl = proxyUrl.toString();
+        }
+        this.rest = new DiscordREST({ token: options.token, proxy: options.proxy });
+    }
+    /**
+     * 连接 Gateway
+     */
+    async connect() {
+        // 获取 Gateway URL
+        const { url } = await this.rest.getGatewayBot();
+        const gatewayUrl = `${url}?v=10&encoding=json`;
+        return this.connectToGateway(gatewayUrl);
+    }
+    /**
+     * 连接到指定 Gateway URL
+     */
+    async connectToGateway(url) {
+        // 动态导入 ws
+        const { WebSocket } = await import('ws');
+        // 如果有代理，使用 socks-proxy-agent (WebSocket 更稳定)
+        let wsOptions = {};
+        if (this.proxyUrl) {
+            try {
+                // 优先使用 SOCKS5 代理 (对 WebSocket 支持更好)
+                // 将 http:// 代理转换为 socks5:// (Clash 混合端口同时支持)
+                const socksUrl = this.proxyUrl.replace(/^https?:\/\//, 'socks5://');
+                // @ts-ignore - socks-proxy-agent 是可选依赖
+                const { SocksProxyAgent } = await import('socks-proxy-agent');
+                wsOptions.agent = new SocksProxyAgent(socksUrl);
+                console.log(`[Gateway] 使用 SOCKS5 代理: ${socksUrl}`);
+            }
+            catch {
+                // 回退到 https-proxy-agent
+                try {
+                    // @ts-ignore - https-proxy-agent 是可选依赖
+                    const { HttpsProxyAgent } = await import('https-proxy-agent');
+                    wsOptions.agent = new HttpsProxyAgent(this.proxyUrl);
+                    console.log(`[Gateway] 使用 HTTP 代理: ${this.proxyUrl}`);
+                }
+                catch {
+                    console.warn('[Gateway] 代理 agent 未安装，将直接连接');
+                }
+            }
+        }
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(url, wsOptions);
+            this.ws.on('open', () => {
+                console.log('[Gateway] WebSocket 已连接');
+            });
+            this.ws.on('message', (data) => {
+                this.handleMessage(JSON.parse(data.toString()));
+            });
+            this.ws.on('close', (code, reason) => {
+                console.log(`[Gateway] WebSocket 关闭: ${code} - ${reason.toString()}`);
+                this.cleanup();
+                this.emit('close', code, reason.toString());
+                // 自动重连
+                if (code !== 1000 && code !== 4004) {
+                    setTimeout(() => this.reconnect(), 5000);
+                }
+            });
+            this.ws.on('error', (error) => {
+                console.error('[Gateway] WebSocket 错误:', error);
+                this.emit('error', error);
+                reject(error);
+            });
+            // 设置超时
+            const timeout = setTimeout(() => {
+                if (!this.isReady) {
+                    reject(new Error('Gateway 连接超时'));
+                }
+            }, 30000);
+            this.once('ready', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    }
+    /**
+     * 处理 Gateway 消息
+     */
+    handleMessage(payload) {
+        const { op, d, s, t } = payload;
+        // 更新序列号
+        if (s !== null) {
+            this.sequence = s;
+        }
+        switch (op) {
+            case GatewayOpcodes.Hello:
+                this.startHeartbeat(d.heartbeat_interval);
+                this.identify();
+                break;
+            case GatewayOpcodes.HeartbeatAck:
+                // 心跳确认
+                break;
+            case GatewayOpcodes.Heartbeat:
+                this.sendHeartbeat();
+                break;
+            case GatewayOpcodes.Dispatch:
+                this.handleDispatch(t, d);
+                break;
+            case GatewayOpcodes.Reconnect:
+                console.log('[Gateway] 收到重连请求');
+                this.reconnect();
+                break;
+            case GatewayOpcodes.InvalidSession:
+                console.log('[Gateway] 会话无效，重新识别');
+                if (d) {
+                    // 可恢复，尝试 resume
+                    setTimeout(() => this.resume(), 1000);
+                }
+                else {
+                    // 不可恢复，重新 identify
+                    this.sessionId = null;
+                    setTimeout(() => this.identify(), 1000);
+                }
+                break;
+        }
+    }
+    /**
+     * 处理 Dispatch 事件
+     */
+    handleDispatch(eventName, data) {
+        switch (eventName) {
+            case 'READY':
+                this.sessionId = data.session_id;
+                this.resumeGatewayUrl = data.resume_gateway_url;
+                this.isReady = true;
+                this.emit('ready', data.user);
+                break;
+            case 'RESUMED':
+                console.log('[Gateway] 会话已恢复');
+                this.emit('resumed');
+                break;
+            case 'MESSAGE_CREATE':
+                this.emit('messageCreate', data);
+                break;
+            case 'MESSAGE_UPDATE':
+                this.emit('messageUpdate', data);
+                break;
+            case 'MESSAGE_DELETE':
+                this.emit('messageDelete', data);
+                break;
+            case 'GUILD_CREATE':
+                this.emit('guildCreate', data);
+                break;
+            case 'GUILD_DELETE':
+                this.emit('guildDelete', data);
+                break;
+            case 'GUILD_MEMBER_ADD':
+                this.emit('guildMemberAdd', data);
+                break;
+            case 'GUILD_MEMBER_REMOVE':
+                this.emit('guildMemberRemove', data);
+                break;
+            case 'INTERACTION_CREATE':
+                this.emit('interactionCreate', data);
+                break;
+            default:
+                // 发送通用事件
+                this.emit('dispatch', eventName, data);
+        }
+    }
+    /**
+     * 发送 Identify
+     */
+    identify() {
+        this.send({
+            op: GatewayOpcodes.Identify,
+            d: {
+                token: this.token,
+                intents: this.intents,
+                properties: {
+                    os: typeof process !== 'undefined' ? process.platform : 'unknown',
+                    browser: 'onebots-lite',
+                    device: 'onebots-lite',
+                },
+            },
+        });
+    }
+    /**
+     * 发送 Resume
+     */
+    resume() {
+        if (!this.sessionId || !this.sequence) {
+            this.identify();
+            return;
+        }
+        this.send({
+            op: GatewayOpcodes.Resume,
+            d: {
+                token: this.token,
+                session_id: this.sessionId,
+                seq: this.sequence,
+            },
+        });
+    }
+    /**
+     * 开始心跳
+     */
+    startHeartbeat(interval) {
+        this.stopHeartbeat();
+        // 首次心跳添加随机抖动
+        const jitter = Math.random() * interval;
+        setTimeout(() => {
+            this.sendHeartbeat();
+            this.heartbeatInterval = setInterval(() => this.sendHeartbeat(), interval);
+        }, jitter);
+    }
+    /**
+     * 停止心跳
+     */
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+    /**
+     * 发送心跳
+     */
+    sendHeartbeat() {
+        this.send({
+            op: GatewayOpcodes.Heartbeat,
+            d: this.sequence,
+        });
+    }
+    /**
+     * 发送数据
+     */
+    send(data) {
+        if (this.ws && this.ws.readyState === 1) {
+            this.ws.send(JSON.stringify(data));
+        }
+    }
+    /**
+     * 重连
+     */
+    async reconnect() {
+        this.cleanup();
+        if (this.resumeGatewayUrl && this.sessionId) {
+            // 尝试恢复
+            try {
+                await this.connectToGateway(`${this.resumeGatewayUrl}?v=10&encoding=json`);
+                this.resume();
+                return;
+            }
+            catch {
+                // 恢复失败，重新连接
+            }
+        }
+        // 重新连接
+        await this.connect();
+    }
+    /**
+     * 清理资源
+     */
+    cleanup() {
+        this.stopHeartbeat();
+        this.isReady = false;
+        if (this.ws) {
+            this.ws.removeAllListeners();
+            if (this.ws.readyState === 1) {
+                this.ws.close();
+            }
+            this.ws = null;
+        }
+    }
+    /**
+     * 断开连接
+     */
+    disconnect() {
+        this.sessionId = null;
+        this.resumeGatewayUrl = null;
+        this.cleanup();
+    }
+    /**
+     * 获取 REST 客户端
+     */
+    getREST() {
+        return this.rest;
+    }
+}
+//# sourceMappingURL=gateway.js.map

package/lib/lite/index.d.ts

@@ -0,0 +1,148 @@
+/**
+ * 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 { InteractionsHandler } from './interactions.js';
+export { DiscordREST, type RESTOptions } from './rest.js';
+export { DiscordGateway, GatewayIntents, GatewayOpcodes, type GatewayOptions } from './gateway.js';
+export { InteractionsHandler, InteractionType, InteractionCallbackType, verifyInteractionSignature, type InteractionWebhookOptions } from './interactions.js';
+export { DiscordLiteBot, type DiscordLiteBotConfig } from './bot.js';
+export type { DiscordUser, DiscordMessage, DiscordGuild, DiscordChannel, DiscordMember, DiscordAttachment } from './bot.js';
+/**
+ * 运行时类型
+ */
+export type RuntimeType = 'node' | 'cloudflare' | 'vercel' | 'deno' | 'bun' | 'browser' | 'unknown';
+/**
+ * 检测当前运行时环境
+ */
+export declare function detectRuntime(): RuntimeType;
+/**
+ * 检测是否支持 WebSocket Gateway
+ */
+export declare function supportsGateway(): boolean;
+/**
+ * Discord Lite 配置
+ */
+export interface DiscordLiteOptions {
+    token: string;
+    intents?: number;
+    proxy?: {
+        url: string;
+        username?: string;
+        password?: string;
+    };
+    mode?: 'gateway' | 'interactions' | 'auto';
+    publicKey?: string;
+    applicationId?: string;
+}
+/**
+ * Discord Lite 统一客户端
+ */
+export declare class DiscordLite extends EventEmitter {
+    private options;
+    private gateway;
+    private interactions;
+    private rest;
+    private runtime;
+    private mode;
+    private user;
+    constructor(options: DiscordLiteOptions);
+    /**
+     * 启动客户端（Gateway 模式）
+     */
+    start(): Promise<void>;
+    /**
+     * 停止客户端
+     */
+    stop(): void;
+    /**
+     * 初始化 Interactions 处理器
+     */
+    initInteractions(): InteractionsHandler;
+    /**
+     * 处理 HTTP 请求（Interactions 模式）
+     */
+    handleRequest(request: Request): Promise<Response>;
+    /**
+     * 获取 REST 客户端
+     */
+    getREST(): DiscordREST;
+    /**
+     * 获取当前用户
+     */
+    getUser(): any;
+    /**
+     * 获取当前运行时
+     */
+    getRuntime(): RuntimeType;
+    /**
+     * 获取当前模式
+     */
+    getMode(): 'gateway' | 'interactions';
+    /** 发送消息 */
+    sendMessage(channelId: string, content: string | {
+        content?: string;
+        embeds?: any[];
+    }): Promise<any>;
+    /** 编辑消息 */
+    editMessage(channelId: string, messageId: string, content: string | {
+        content?: string;
+        embeds?: any[];
+    }): Promise<any>;
+    /** 删除消息 */
+    deleteMessage(channelId: string, messageId: string): Promise<any>;
+    /** 获取消息 */
+    getMessage(channelId: string, messageId: string): Promise<any>;
+    /** 获取服务器 */
+    getGuild(guildId: string): Promise<any>;
+    /** 获取服务器成员 */
+    getGuildMember(guildId: string, userId: string): Promise<any>;
+}
+/**
+ * 创建 Discord Lite 客户端的便捷方法
+ */
+export declare function createClient(options: DiscordLiteOptions): DiscordLite;
+//# sourceMappingURL=index.d.ts.map