@alemonjs/qq-bot 0.0.12 → 0.0.13

package/lib/sdk/client.js

@@ -0,0 +1,228 @@
+import { QQBotAPI } from './api.js';
+import bodyParser from 'koa-bodyparser';
+import Router from 'koa-router';
+import { WebhookAPI } from './webhook.secret.js';
+import Koa from 'koa';
+import { config } from './config.js';
+import { v4 } from 'uuid';
+import { WebSocketServer, WebSocket } from 'ws';
+
+class QQBotClient extends QQBotAPI {
+    #events = {};
+    #app = null;
+    #count = 0;
+    #client = [];
+    #ws = null;
+    /**
+     * 设置配置
+     * @param opstion
+     */
+    constructor(opstion) {
+        super();
+        if (opstion.secret)
+            config.set('secret', opstion.secret);
+        if (opstion.app_id)
+            config.set('app_id', opstion.app_id);
+        if (opstion.token)
+            config.set('token', opstion.token);
+        if (opstion.port)
+            config.set('port', opstion.port);
+        if (opstion.ws)
+            config.set('ws', opstion.ws);
+    }
+    /**
+     * 注册事件处理程序
+     * @param key 事件名称
+     * @param val 事件处理函数
+     */
+    on(key, val) {
+        if (!this.#events[key]) {
+            this.#events[key] = [];
+        }
+        this.#events[key].push(val);
+        return this;
+    }
+    /**
+     * 定时鉴权
+     * @param cfg
+     * @returns
+     */
+    async #setTimeoutBotConfig() {
+        const callBack = async () => {
+            const app_id = config.get('app_id');
+            if (!app_id)
+                return;
+            const secret = config.get('secret');
+            if (!secret)
+                return;
+            // 发送请求
+            const data = await this.getAuthentication(app_id, secret).then(res => res.data);
+            config.set('access_token', data.access_token);
+            console.info('refresh', data.expires_in, 's');
+            setTimeout(callBack, data.expires_in * 1000);
+        };
+        await callBack();
+    }
+    /**
+     *
+     * @param cfg
+     * @param conversation
+     */
+    connect() {
+        try {
+            const ws = config.get('ws');
+            if (!ws) {
+                this.#setTimeoutBotConfig();
+                this.#app = new Koa();
+                this.#app.use(bodyParser());
+                const router = new Router();
+                const port = config.get('port');
+                const secret = config.get('secret');
+                const route = config.get('route') ?? '/webhook';
+                const cfg = {
+                    secret: secret ?? '',
+                    port: port ? Number(port) : 17157
+                };
+                const ntqqWebhook = new WebhookAPI({
+                    secret: cfg.secret
+                });
+                this.#app.use(async (ctx, next) => {
+                    let rawData = '';
+                    ctx.req.on('data', chunk => (rawData += chunk));
+                    ctx.req.on('end', () => (ctx.request.rawBody = rawData));
+                    await next();
+                });
+                // 启动服务
+                router.post(route, async (ctx) => {
+                    const sign = ctx.req.headers['x-signature-ed25519'];
+                    const timestamp = ctx.req.headers['x-signature-timestamp'];
+                    const rawBody = ctx.request.rawBody;
+                    const isValid = ntqqWebhook.validSign(timestamp, rawBody, String(sign));
+                    if (!isValid) {
+                        ctx.status = 400;
+                        ctx.body = { msg: 'invalid signature' };
+                        return;
+                    }
+                    const body = ctx.request.body;
+                    if (body.op == 13) {
+                        ctx.status = 200;
+                        ctx.body = {
+                            // 返回明文 token
+                            plain_token: body.d.plain_token,
+                            // 生成签名
+                            signature: ntqqWebhook.getSign(body.d.event_ts, body.d.plain_token)
+                        };
+                    }
+                    else if (body.op == 0) {
+                        ctx.status = 204;
+                        // 根据事件类型，处理事件
+                        for (const event of this.#events[body.t] || []) {
+                            event(body.d);
+                        }
+                        const access_token = config.get('access_token');
+                        // 也可以分法到客户端。 发送失败需要处理 或清理调
+                        for (const client of this.#client) {
+                            try {
+                                if (access_token)
+                                    body['access_token'] = access_token;
+                                client.ws.send(JSON.stringify(body));
+                            }
+                            catch (e) {
+                                this.#error(e);
+                            }
+                        }
+                    }
+                });
+                this.#app.use(router.routes());
+                this.#app.use(router.allowedMethods());
+                // 启动服务
+                const server = this.#app.listen(cfg.port, () => {
+                    console.log('Server running at http://localhost:' + cfg.port + route);
+                });
+                // 创建 WebSocketServer 并监听同一个端口
+                const wss = new WebSocketServer({ server: server });
+                console.log('Server running at wss://localhost:' + cfg.port + '/');
+                // 处理客户端连接
+                wss.on('connection', ws => {
+                    const clientId = v4();
+                    ws['clientId'] = clientId;
+                    console.log(clientId, 'connection');
+                    this.#client.push({ id: clientId, ws });
+                    // 处理消息事件
+                    ws.on('message', (message) => {
+                        // 拿到消息
+                        try {
+                            const body = JSON.parse(message.toString());
+                            for (const event of this.#events[body.t] || []) {
+                                event(body.d);
+                            }
+                        }
+                        catch (e) {
+                            this.#error(e);
+                        }
+                    });
+                    // 处理关闭事件
+                    ws.on('close', () => {
+                        console.log(`${clientId} disconnected`);
+                        this.#client = this.#client.filter(client => client.id !== clientId);
+                    });
+                });
+            }
+            else {
+                const reconnect = () => {
+                    // 使用了ws服务器
+                    this.#ws = new WebSocket(ws);
+                    this.#ws.on('open', () => {
+                        this.#count = 0;
+                        console.log('ws connected');
+                    });
+                    this.#ws.on('message', data => {
+                        try {
+                            // 拿到消息
+                            const body = JSON.parse(data.toString());
+                            const access_token = body['access_token'];
+                            if (access_token)
+                                config.set('access_token', access_token);
+                            for (const event of this.#events[body.t] || []) {
+                                event(body.d);
+                            }
+                        }
+                        catch (e) {
+                            this.#error(e);
+                        }
+                    });
+                    this.#ws.on('close', () => {
+                        console.log('ws closed');
+                        // 重连5次，超过5次不再重连
+                        if (this.#count > 5)
+                            return;
+                        // 1.3s 后重连
+                        setTimeout(() => {
+                            reconnect();
+                        }, 1300);
+                    });
+                    this.#ws.on('error', e => {
+                        this.#error(e);
+                    });
+                };
+                reconnect();
+            }
+        }
+        catch (e) {
+            this.#error(e);
+        }
+    }
+    /**
+     *
+     * @param error
+     */
+    #error(error) {
+        if (this.#events['ERROR']) {
+            for (const event of this.#events['ERROR'] || []) {
+                event(error);
+            }
+        }
+    }
+}
+
+export { QQBotClient };

package/lib/sdk/config.js

@@ -0,0 +1,3 @@
+const config = new Map();
+
+export { config };

package/lib/sdk/counter.js

@@ -0,0 +1,19 @@
+class Counter {
+    #counter = 1;
+    #val = 0;
+    constructor(initialValue) {
+        this.#counter = initialValue;
+        this.#val = initialValue;
+    }
+    getNextId() {
+        return ++this.#counter;
+    }
+    get() {
+        return this.#counter;
+    }
+    reStart() {
+        this.#counter = this.#val;
+    }
+}
+
+export { Counter };

package/lib/sdk/from.js

@@ -0,0 +1,44 @@
+import { existsSync, createReadStream } from 'fs';
+import { Readable, isReadable } from 'stream';
+import { basename } from 'path';
+import { fileTypeFromBuffer, fileTypeFromStream } from 'file-type';
+
+/**
+ * 创建form
+ * @param image
+ * @param name
+ * @returns
+ */
+async function createPicFrom(image, name = 'image.jpg') {
+    let picData;
+    // 是 string
+    if (typeof image === 'string') {
+        if (!existsSync(image))
+            return false;
+        if (!name)
+            name = basename(image);
+        picData = createReadStream(image);
+        // 是 buffer
+    }
+    else if (Buffer.isBuffer(image)) {
+        const file = await fileTypeFromBuffer(image);
+        if (!name)
+            name = 'file.' + file?.ext;
+        picData = new Readable();
+        picData.push(image);
+        picData.push(null);
+        // 是 文件流
+    }
+    else if (isReadable(image)) {
+        const file = await fileTypeFromStream(image);
+        if (!name)
+            name = 'file.' + file?.ext;
+        picData = image;
+    }
+    else {
+        return false;
+    }
+    return { picData, image, name };
+}
+
+export { createPicFrom };

package/lib/sdk/intents.js

@@ -0,0 +1,102 @@
+/**
+ * GUILDS (1 << 0)
+  - GUILD_CREATE           // 当机器人加入新guild时
+  - GUILD_UPDATE           // 当guild资料发生变更时
+  - GUILD_DELETE           // 当机器人退出guild时
+  - CHANNEL_CREATE         // 当channel被创建时
+  - CHANNEL_UPDATE         // 当channel被更新时
+  - CHANNEL_DELETE         // 当channel被删除时
+
+GUILD_MEMBERS (1 << 1)
+  - GUILD_MEMBER_ADD       // 当成员加入时
+  - GUILD_MEMBER_UPDATE    // 当成员资料变更时
+  - GUILD_MEMBER_REMOVE    // 当成员被移除时
+
+GUILD_MESSAGES (1 << 9)    // 消息事件，仅 *私域* 机器人能够设置此 intents。
+  - MESSAGE_CREATE         // 发送消息事件，代表频道内的全部消息，而不只是 at 机器人的消息。内容与 AT_MESSAGE_CREATE 相同
+  - MESSAGE_DELETE         // 删除（撤回）消息事件
+
+GUILD_MESSAGE_REACTIONS (1 << 10)
+  - MESSAGE_REACTION_ADD    // 为消息添加表情表态
+  - MESSAGE_REACTION_REMOVE // 为消息删除表情表态
+
+DIRECT_MESSAGE (1 << 12)
+  - DIRECT_MESSAGE_CREATE   // 当收到用户发给机器人的私信消息时
+  - DIRECT_MESSAGE_DELETE   // 删除（撤回）消息事件
+
+
+GROUP_AND_C2C_EVENT (1 << 25)
+  - C2C_MESSAGE_CREATE      // 用户单聊发消息给机器人时候
+  - FRIEND_ADD              // 用户添加使用机器人
+  - FRIEND_DEL              // 用户删除机器人
+  - C2C_MSG_REJECT          // 用户在机器人资料卡手动关闭"主动消息"推送
+  - C2C_MSG_RECEIVE         // 用户在机器人资料卡手动开启"主动消息"推送开关
+  - GROUP_AT_MESSAGE_CREATE // 用户在群里@机器人时收到的消息
+  - GROUP_ADD_ROBOT         // 机器人被添加到群聊
+  - GROUP_DEL_ROBOT         // 机器人被移出群聊
+  - GROUP_MSG_REJECT        // 群管理员主动在机器人资料页操作关闭通知
+  - GROUP_MSG_RECEIVE       // 群管理员主动在机器人资料页操作开启通知
+
+INTERACTION (1 << 26)
+  - INTERACTION_CREATE     // 互动事件创建时
+
+MESSAGE_AUDIT (1 << 27)
+  - MESSAGE_AUDIT_PASS     // 消息审核通过
+  - MESSAGE_AUDIT_REJECT   // 消息审核不通过
+
+FORUMS_EVENT (1 << 28)  // 论坛事件，仅 *私域* 机器人能够设置此 intents。
+  - FORUM_THREAD_CREATE     // 当用户创建主题时
+  - FORUM_THREAD_UPDATE     // 当用户更新主题时
+  - FORUM_THREAD_DELETE     // 当用户删除主题时
+  - FORUM_POST_CREATE       // 当用户创建帖子时
+  - FORUM_POST_DELETE       // 当用户删除帖子时
+  - FORUM_REPLY_CREATE      // 当用户回复评论时
+  - FORUM_REPLY_DELETE      // 当用户回复评论时
+  - FORUM_PUBLISH_AUDIT_RESULT      // 当用户发表审核通过时
+
+AUDIO_ACTION (1 << 29)
+  - AUDIO_START             // 音频开始播放时
+  - AUDIO_FINISH            // 音频播放结束时
+  - AUDIO_ON_MIC            // 上麦时
+  - AUDIO_OFF_MIC           // 下麦时
+
+PUBLIC_GUILD_MESSAGES (1 << 30) // 消息事件，此为公域的消息事件
+  - AT_MESSAGE_CREATE       // 当收到@机器人的消息时
+  - PUBLIC_MESSAGE_DELETE   // 当频道的消息被删除时
+ */
+/**
+ * 订阅枚举
+ */
+/**
+ * 订阅事件集合
+ */
+const intentsMap = {
+    GUILDS: 1 << 0,
+    GUILD_MEMBERS: 1 << 1,
+    GUILD_MESSAGES: 1 << 9,
+    GUILD_MESSAGE_REACTIONS: 1 << 10,
+    DIRECT_MESSAGE: 1 << 12,
+    GROUP_AND_C2C_EVENT: 1 << 25,
+    INTERACTION: 1 << 26,
+    MESSAGE_AUDIT: 1 << 27,
+    FORUMS_EVENT: 1 << 28,
+    AUDIO_ACTION: 1 << 29,
+    PUBLIC_GUILD_MESSAGES: 1 << 30
+};
+/**
+ *
+ * @param intents
+ * @returns
+ */
+function getIntentsMask(intents) {
+    let intentsMask = 0;
+    for (const item of intents) {
+        const mask = intentsMap[item];
+        if (mask) {
+            intentsMask |= mask;
+        }
+    }
+    return intentsMask;
+}
+
+export { getIntentsMask };

package/lib/sdk/typing.d.ts

@@ -0,0 +1,56 @@
+type MessageType = 0 | 1 | 2 | 3 | 4 | 7;
+type FileType = 1 | 2 | 3 | 4;
+interface ButtonType {
+    id: string;
+    render_data: {
+        label: string;
+        visited_label: string;
+        style: number;
+    };
+    action: {
+        type: number;
+        permission: {
+            type: number;
+        };
+        reply?: boolean;
+        enter?: boolean;
+        unsupport_tips: string;
+        data: string;
+    };
+}
+interface KeyboardType {
+    id?: string;
+    content?: {
+        rows: {
+            buttons: ButtonType[];
+        }[];
+    };
+}
+interface MarkdownType {
+    /** markdown 模版id，申请模版后获得 */
+    custom_template_id: string;
+    /** 原生 markdown 文本内容（内邀使用） */
+    content?: string;
+    /** 模版内变量与填充值的kv映射 */
+    params?: Array<{
+        key: string;
+        values: string[];
+    }>;
+}
+interface ApiRequestData {
+    content?: string;
+    msg_type: MessageType;
+    markdown?: MarkdownType;
+    keyboard?: KeyboardType;
+    media?: {
+        file_info: string;
+    };
+    ark?: any;
+    image?: any;
+    message_reference?: any;
+    event_id?: any;
+    msg_id?: string;
+    msg_seq?: number;
+}
+
+export type { ApiRequestData, ButtonType, FileType, KeyboardType, MarkdownType, MessageType };

package/lib/sdk/webhook.secret.js

@@ -0,0 +1,53 @@
+import { ed25519 } from '@noble/curves/ed25519';
+
+class WebhookAPI {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     *  验证签名
+     * @param ts
+     * @param body
+     * @param sign
+     * @returns
+     */
+    validSign(ts, body, sign) {
+        const { publicKey } = this.getKey();
+        const sig = Buffer.isBuffer(sign) ? sign : Buffer.from(sign, 'hex');
+        const httpBody = Buffer.from(body);
+        const msg = Buffer.from(ts + httpBody);
+        return ed25519.verify(sig, msg, publicKey);
+    }
+    /**
+     *   生成签名
+     * @param eventTs
+     * @param plainToken
+     * @returns
+     */
+    getSign(eventTs, plainToken) {
+        const { privateKey } = this.getKey();
+        const msg = Buffer.from(eventTs + plainToken);
+        const signature = Buffer.from(ed25519.sign(msg, privateKey)).toString('hex');
+        return signature;
+    }
+    /**
+     * 获取 key
+     * @returns
+     */
+    getKey() {
+        let seed = this.config.secret;
+        if (!seed)
+            throw new Error("secret not set, can't calc ed25519 key");
+        while (seed.length < 32)
+            seed = seed.repeat(2); // Ed25519 的种子大小是 32 字节
+        seed = seed.slice(0, 32); // 修剪到 32 字节
+        const privateKey = Buffer.from(seed);
+        return {
+            privateKey,
+            publicKey: ed25519.getPublicKey(privateKey)
+        };
+    }
+}
+
+export { WebhookAPI };