@alemonjs/onebot 2.1.0-alpha.0 → 2.1.0-alpha.10

package/README.md

@@ -9,4 +9,10 @@ onebot:
   reverse_enable: false # 启用后正向连接配置失效，地址：ws://127.0.0.1:17158
   reverse_port: 17158 # 返向连接服务端口，启用反向连接后生效
   master_key: null
+  # 使用 user_key
+  master_key:
+     - 'xxx'
+  # 使用 user_id
+  master_id:
+     - 'yyy'
 ```

package/lib/config.js

@@ -1,9 +1,20 @@
-import { getConfigValue } from 'alemonjs';
+import { getConfigValue, useUserHashKey } from 'alemonjs';
 
 const platform = 'onebot';
 const getOneBotConfig = () => {
     const value = getConfigValue() || {};
     return value[platform] || {};
 };
+const getMaster = (UserId) => {
+    const config = getOneBotConfig();
+    const master_key = config.master_key || [];
+    const master_id = config.master_id || [];
+    const UserKey = useUserHashKey({
+        Platform: platform,
+        UserId: UserId
+    });
+    const is = master_key.includes(UserKey) || master_id.includes(UserId);
+    return [is, UserKey];
+};
 
-export { getOneBotConfig, platform };
+export { getMaster, getOneBotConfig, platform };

package/lib/db.js

@@ -0,0 +1,4 @@
+const BotMe = {
+    id: ''};
+
+export { BotMe };

package/lib/hook.d.ts

@@ -0,0 +1,38 @@
+import { EventKeys, Events } from 'alemonjs';
+import { OneBotAPI } from './sdk/api.js';
+import { MESSAGES_TYPE, DIRECT_MESSAGE_TYPE } from './sdk/types.js';
+
+type MAP = {
+    'message.create': MESSAGES_TYPE;
+    'private.message.create': DIRECT_MESSAGE_TYPE;
+    'interaction.create': undefined;
+    'private.interaction.create': undefined;
+    'message.update': undefined;
+    'message.delete': undefined;
+    'message.reaction.add': undefined;
+    'message.reaction.remove': undefined;
+    'channal.create': undefined;
+    'channal.delete': undefined;
+    'guild.join': undefined;
+    'guild.exit': undefined;
+    'member.add': undefined;
+    'member.remove': undefined;
+    'private.message.update': undefined;
+    'private.message.delete': undefined;
+    'private.friend.add': undefined;
+    'private.guild.add': undefined;
+};
+/**
+ *
+ * @param event
+ * @returns
+ */
+declare const useValue: <T extends EventKeys>(event: Events[T]) => readonly [MAP[T]];
+/**
+ *
+ * @param event
+ * @returns
+ */
+declare const useClient: <T extends EventKeys>(event: Events[T]) => readonly [OneBotAPI, MAP[T]];
+
+export { useClient, useValue };

package/lib/hook.js

@@ -0,0 +1,24 @@
+import { createEventValue, useClient as useClient$1 } from 'alemonjs';
+import { OneBotAPI } from './sdk/api.js';
+
+/**
+ *
+ * @param event
+ * @returns
+ */
+const useValue = (event) => {
+    const value = createEventValue(event);
+    return [value];
+};
+/**
+ *
+ * @param event
+ * @returns
+ */
+const useClient = (event) => {
+    const [client] = useClient$1(event, OneBotAPI);
+    const value = createEventValue(event);
+    return [client, value];
+};
+
+export { useClient, useValue };

package/lib/index.d.ts

@@ -1,6 +1,7 @@
 export { platform } from './config.js';
 export { OneBotAPI as API } from './sdk/api.js';
+export { useClient, useValue } from './hook.js';
 
-declare const _default: () => void;
+declare const main: () => void;
 
-export { _default as default };
+export { main as default };

package/lib/index.js

@@ -1,13 +1,13 @@
-import { cbpPlatform, useUserHashKey, createResult, ResultCode } from 'alemonjs';
+import { cbpPlatform, createResult, ResultCode } from 'alemonjs';
 import { getBufferByURL } from 'alemonjs/utils';
-import { OneBotClient } from './sdk/wss.js';
 import { readFileSync } from 'fs';
-import { getOneBotConfig, platform } from './config.js';
+import { getOneBotConfig, getMaster, platform } from './config.js';
+import { OneBotClient } from './sdk/wss.js';
+import { BotMe } from './db.js';
 export { OneBotAPI as API } from './sdk/api.js';
+export { useClient, useValue } from './hook.js';
 
-const MyBot = {
-    id: ''};
-var index = () => {
+const main = () => {
     const config = getOneBotConfig();
     const client = new OneBotClient({
         // url
@@ -19,8 +19,8 @@ var index = () => {
         // 反向连接端口
         reverse_port: config?.reverse_port ?? 17158
     });
-    client.connect();
-    const url = `ws://127.0.0.1:${process.env?.port || config?.port || 17117}`;
+    void client.connect();
+    const url = `ws://127.0.0.1:${process.env?.port || 17117}`;
     const cbp = cbpPlatform(url);
     const createUserAvatar = (id) => {
         return `https://q1.qlogo.cn/g?b=qq&s=0&nk=${id}`;
@@ -28,7 +28,7 @@ var index = () => {
     const getMessageText = (message) => {
         let msg = '';
         for (const item of message) {
-            if (item.type == 'text') {
+            if (item.type === 'text') {
                 msg += item.data.text;
             }
         }
@@ -36,18 +36,14 @@ var index = () => {
     };
     client.on('META', event => {
         if (event?.self_id) {
-            MyBot.id = String(event.self_id);
+            BotMe.id = String(event.self_id);
         }
     });
     client.on('MESSAGES', event => {
-        const uis = config?.master_id ?? [];
         const msg = getMessageText(event.message);
         const UserId = String(event.user_id);
         const UserAvatar = createUserAvatar(UserId);
-        const UserKey = useUserHashKey({
-            Platform: platform,
-            UserId
-        });
+        const [isMaster, UserKey] = getMaster(UserId);
         const groupId = String(event.group_id);
         // 定义消
         const e = {
@@ -55,7 +51,7 @@ var index = () => {
             Platform: platform,
             GuildId: groupId,
             ChannelId: groupId,
-            IsMaster: uis.includes(UserId),
+            IsMaster: isMaster,
             SpaceId: groupId,
             IsBot: false,
             UserId: UserId,
@@ -72,19 +68,15 @@ var index = () => {
         cbp.send(e);
     });
     client.on('DIRECT_MESSAGE', event => {
-        const uis = config?.master_id ?? [];
         const msg = getMessageText(event.message);
         const UserId = String(event.user_id);
         const UserAvatar = createUserAvatar(UserId);
-        const UserKey = useUserHashKey({
-            Platform: platform,
-            UserId
-        });
+        const [isMaster, UserKey] = getMaster(UserId);
         // 定义消
         const e = {
             name: 'private.message.create',
             Platform: platform,
-            IsMaster: uis.includes(String(event.user_id)),
+            IsMaster: isMaster,
             IsBot: false,
             UserId: UserId,
             UserName: event.sender.nickname,
@@ -99,228 +91,300 @@ var index = () => {
         };
         cbp.send(e);
     });
-    // 错误处理
-    client.on('ERROR', event => {
-        logger.error(event);
-    });
-    const sendGroup = async (event, val) => {
-        if (val.length < 0)
-            return [];
-        const content = val
-            .filter(item => item.type == 'Mention' || item.type == 'Text')
-            .map(item => item.value)
-            .join('');
-        try {
-            if (content) {
-                const res = await client.sendGroupMessage({
-                    group_id: event.ChannelId,
-                    message: [
-                        {
-                            type: 'text',
-                            data: {
-                                text: content
-                            }
+    /**
+     * @param val
+     * @returns
+     */
+    const DataToMessage = async (val = []) => {
+        // 空元素
+        const empty = {
+            type: 'text',
+            data: {
+                text: ''
+            }
+        };
+        const message = await Promise.all(val.map(async (item) => {
+            if (item.type === 'Text') {
+                return {
+                    type: 'text',
+                    data: {
+                        text: item.value
+                    }
+                };
+            }
+            else if (item.type === 'Mention') {
+                const options = item.options || {};
+                if (options.belong === 'everyone') {
+                    return {
+                        type: 'at',
+                        data: {
+                            qq: 'all',
+                            nickname: ''
                         }
-                    ]
-                });
-                return [createResult(ResultCode.Ok, 'client.groupOpenMessages', res)];
+                    };
+                }
+                else if (options.belong === 'user') {
+                    return {
+                        type: 'at',
+                        data: {
+                            qq: item.value
+                        }
+                    };
+                }
+                return empty;
             }
-            const images = val.filter(item => item.type == 'Image' || item.type == 'ImageFile' || item.type == 'ImageURL');
-            if (images) {
-                return Promise.all(images.map(async (item) => {
-                    let data = null;
-                    if (item.type === 'ImageFile') {
-                        const db = readFileSync(item.value);
-                        data = db;
+            else if (item.type === 'Image') {
+                return {
+                    type: 'image',
+                    data: {
+                        file: `base64://${item.value}`
                     }
-                    else if (item.type === 'ImageURL') {
-                        const db = await getBufferByURL(item.value);
-                        data = db;
+                };
+            }
+            else if (item.type === 'ImageFile') {
+                const db = readFileSync(item.value);
+                return {
+                    type: 'image',
+                    data: {
+                        file: `base64://${db.toString('base64')}`
                     }
-                    else {
-                        // data = item.value
-                        data = Buffer.from(item.value, 'base64');
+                };
+            }
+            else if (item.type === 'ImageURL') {
+                const db = await getBufferByURL(item.value);
+                return {
+                    type: 'image',
+                    data: {
+                        file: `base64://${db.toString('base64')}`
                     }
-                    client.sendGroupMessage({
-                        group_id: event.ChannelId,
-                        message: [
-                            {
-                                type: 'image',
-                                data: {
-                                    file: `base64://${data.toString('base64')}`
-                                }
-                            }
-                        ]
-                    });
-                    return createResult(ResultCode.Ok, 'client.groupOpenMessages', {
-                        id: null
-                    });
-                }));
+                };
             }
+            return empty;
+        }));
+        return message;
+    };
+    /**
+     *
+     * @param ChannelId
+     * @param val
+     * @returns
+     */
+    const sendGroup = async (ChannelId, val) => {
+        if (val.length < 0) {
+            return [];
+        }
+        try {
+            const message = await DataToMessage(val);
+            const res = await client.sendGroupMessage({
+                group_id: ChannelId,
+                message: message
+            });
+            return [createResult(ResultCode.Ok, 'client.groupOpenMessages', res)];
         }
         catch (error) {
             return [createResult(ResultCode.Fail, 'client.groupOpenMessages', error)];
         }
-        return [];
     };
     /**
      *
-     * @param event
+     * @param UserId
      * @param val
      * @returns
      */
-    const sendPrivate = async (event, val) => {
-        if (val.length < 0)
-            return Promise.all([]);
-        const content = val
-            .filter(item => item.type == 'Link' || item.type == 'Mention' || item.type == 'Text')
-            .map(item => item.value)
-            .join('');
+    const sendPrivate = async (UserId, val) => {
+        if (val.length < 0) {
+            return [];
+        }
         try {
-            if (content) {
-                const res = await client.sendPrivateMessage({
-                    user_id: event.UserId,
-                    message: [
-                        {
-                            type: 'text',
-                            data: {
-                                text: content
-                            }
-                        }
-                    ]
-                });
-                return [createResult(ResultCode.Ok, 'client.sendPrivateMessage', res)];
-            }
-            const images = val.filter(item => item.type == 'Image' || item.type == 'ImageFile' || item.type == 'ImageURL');
-            if (images) {
-                return Promise.all(images.map(async (item) => {
-                    let data = null;
-                    if (item.type === 'ImageFile') {
-                        const db = readFileSync(item.value);
-                        data = db;
-                    }
-                    else if (item.type === 'ImageURL') {
-                        const db = await getBufferByURL(item.value);
-                        data = db;
-                    }
-                    else {
-                        // data = item.value
-                        data = Buffer.from(item.value, 'base64');
-                    }
-                    client.sendPrivateMessage({
-                        user_id: event.UserId,
-                        message: [
-                            {
-                                type: 'image',
-                                data: {
-                                    file: `base64://${data.toString('base64')}`
-                                }
-                            }
-                        ]
-                    });
-                    return createResult(ResultCode.Ok, 'client.sendPrivateMessage', {
-                        id: null
-                    });
-                }));
-            }
+            const message = await DataToMessage(val);
+            const res = await client.sendPrivateMessage({
+                user_id: UserId,
+                message: message
+            });
+            return [createResult(ResultCode.Ok, 'client.groupOpenMessages', res)];
         }
         catch (error) {
-            return [createResult(ResultCode.Fail, 'client.sendPrivateMessage', error)];
+            return [createResult(ResultCode.Fail, 'client.groupOpenMessages', error)];
         }
-        return [];
     };
     const api = {
         active: {
             send: {
-                channel: (event, val) => {
-                    return sendGroup(event, val);
+                channel: (SpaceId, val) => {
+                    return sendGroup(Number(SpaceId), val);
                 },
-                user: (event, val) => {
-                    return sendPrivate(event, val);
+                user: (OpenId, val) => {
+                    return sendPrivate(Number(OpenId), val);
                 }
             }
         },
         use: {
             send: (event, val) => {
-                if (val.length < 0)
+                if (val.length < 0) {
                     return Promise.all([]);
-                if (event['name'] == 'private.message.create') {
-                    return sendPrivate(event, val);
                 }
-                else if (event['name'] == 'message.create') {
-                    return sendGroup(event, val);
+                if (event['name'] === 'private.message.create') {
+                    const UserId = Number(event.UserId);
+                    return sendPrivate(UserId, val);
+                }
+                else if (event['name'] === 'message.create') {
+                    const GroupId = Number(event.ChannelId);
+                    return sendGroup(GroupId, val);
                 }
                 return Promise.all([]);
             },
-            mention: async (event) => {
-                const uis = config?.master_id ?? [];
+            mention: event => {
                 const e = event.value;
-                if (event['name'] == 'message.create' || event['name'] == 'private.message.create') {
-                    const Metions = [];
+                const names = ['message.create', 'private.message.create'];
+                if (names.includes(event.name)) {
+                    const Mentions = [];
                     for (const item of e.message) {
-                        if (item.type == 'at') {
+                        if (item.type === 'at') {
                             let isBot = false;
-                            const uid = String(item.data.qq);
-                            if (uid == 'all') {
+                            const UserId = String(item.data.qq);
+                            if (UserId === 'all') {
                                 continue;
                             }
-                            if (uid == MyBot.id) {
+                            if (UserId === BotMe.id) {
                                 isBot = true;
                             }
-                            const avatar = createUserAvatar(uid);
-                            Metions.push({
-                                UserId: uid,
-                                UserKey: useUserHashKey({
-                                    Platform: platform,
-                                    UserId: uid
-                                }),
+                            const [isMaster, UserKey] = getMaster(UserId);
+                            const avatar = createUserAvatar(UserId);
+                            Mentions.push({
+                                UserId: UserId,
+                                IsMaster: isMaster,
+                                UserKey: UserKey,
                                 UserName: item.data?.nickname,
                                 UserAvatar: avatar,
-                                IsMaster: uis.includes(uid),
                                 IsBot: isBot
                             });
                         }
                     }
-                    return Metions;
+                    return new Promise(resolve => resolve(Mentions));
                 }
-                return [];
+                return new Promise(resolve => resolve([]));
+            },
+            delete(messageId) {
+                return client.deleteMsg({ message_id: Number(messageId) });
+            },
+            file: {
+                channel: client.uploadGroupFile.bind(client),
+                user: client.uploadPrivateFile.bind(client)
+            },
+            forward: {
+                channel: client.sendGroupForward.bind(client),
+                user: client.sendPrivateForward.bind(client)
             }
         }
     };
-    cbp.onactions(async (data, consume) => {
-        if (data.action === 'message.send') {
-            const event = data.payload.event;
-            const paramFormat = data.payload.params.format;
-            const res = await api.use.send(event, paramFormat);
-            consume(res);
-        }
-        else if (data.action === 'message.send.channel') {
-            const channel_id = data.payload.ChannelId;
-            const val = data.payload.params.format;
-            const res = await api.active.send.channel(channel_id, val);
-            consume(res);
-        }
-        else if (data.action === 'message.send.user') {
-            const user_id = data.payload.UserId;
-            const val = data.payload.params.format;
-            const res = await api.active.send.user(user_id, val);
-            consume(res);
-        }
-        else if (data.action === 'mention.get') {
-            const event = data.payload.event;
-            const res = await api.use.mention(event);
-            consume([createResult(ResultCode.Ok, '请求完成', res)]);
+    const onactions = async (data, consume) => {
+        switch (data.action) {
+            case 'message.send': {
+                const event = data.payload.event;
+                const paramFormat = data.payload.params.format;
+                const res = await api.use.send(event, paramFormat);
+                return consume(res);
+            }
+            case 'message.send.channel': {
+                const channel_id = data.payload.ChannelId;
+                const val = data.payload.params.format;
+                const res = await api.active.send.channel(channel_id, val);
+                return consume(res);
+            }
+            case 'message.send.user': {
+                const user_id = data.payload.UserId;
+                const val = data.payload.params.format;
+                const res = await api.active.send.user(user_id, val);
+                return consume(res);
+            }
+            case 'mention.get': {
+                const event = data.payload.event;
+                const res = await api.use.mention(event);
+                return consume([createResult(ResultCode.Ok, '请求完成', res)]);
+            }
+            case 'message.delete': {
+                const res = await api.use
+                    .delete(data.payload.MessageId)
+                    .then(res => createResult(ResultCode.Ok, data.action, res))
+                    .catch(err => createResult(ResultCode.Fail, data.action, err));
+                return consume([res]);
+            }
+            case 'file.send.channel': {
+                const res = await api.use.file
+                    .channel(data.payload.ChannelId, data.payload.params)
+                    .then(res => createResult(ResultCode.Ok, data.action, res))
+                    .catch(err => createResult(ResultCode.Fail, data.action, err));
+                return consume([res]);
+            }
+            case 'file.send.user': {
+                const res = await api.use.file
+                    .user(data.payload.UserId, data.payload.params)
+                    .then(res => createResult(ResultCode.Ok, data.action, res))
+                    .catch(err => createResult(ResultCode.Fail, data.action, err));
+                return consume([res]);
+            }
+            case 'message.forward.channel': {
+                const res = await api.use.forward
+                    .channel(data.payload.ChannelId, data.payload.params.map(i => ({
+                    ...i,
+                    content: DataToMessage(i.content)
+                })))
+                    .then(res => createResult(ResultCode.Ok, data.action, res))
+                    .catch(err => createResult(ResultCode.Fail, data.action, err));
+                return consume([res]);
+            }
+            case 'message.forward.user': {
+                const res = await api.use.forward
+                    .user(data.payload.UserId, data.payload.params.map(i => ({
+                    ...i,
+                    content: DataToMessage(i.content)
+                })))
+                    .then(res => createResult(ResultCode.Ok, data.action, res))
+                    .catch(err => createResult(ResultCode.Fail, data.action, err));
+                return consume([res]);
+            }
         }
-    });
-    // 处理 api 调用
-    cbp.onapis(async (data, consume) => {
+    };
+    cbp.onactions((data, consume) => void onactions(data, consume));
+    const onapis = async (data, consume) => {
         const key = data.payload?.key;
         if (client[key]) {
             const params = data.payload.params;
             const res = await client[key](...params);
             consume([createResult(ResultCode.Ok, '请求完成', res)]);
         }
+    };
+    // 处理 api 调用
+    cbp.onapis((data, consume) => void onapis(data, consume));
+};
+const mainProcess = () => {
+    ['SIGINT', 'SIGTERM', 'SIGQUIT', 'disconnect'].forEach(sig => {
+        process?.on?.(sig, () => {
+            logger?.info?.(`[alemonjs][${sig}] 收到信号，正在关闭...`);
+            setImmediate(() => process.exit(0));
+        });
+    });
+    process?.on?.('exit', code => {
+        logger?.info?.(`[alemonjs][exit] 进程退出，code=${code}`);
+    });
+    // 监听主进程消息
+    process.on('message', msg => {
+        try {
+            const data = typeof msg === 'string' ? JSON.parse(msg) : msg;
+            if (data?.type === 'start') {
+                main();
+            }
+            else if (data?.type === 'stop') {
+                process.exit(0);
+            }
+        }
+        catch { }
     });
+    // 主动发送 ready 消息
+    if (process.send) {
+        process.send(JSON.stringify({ type: 'ready' }));
+    }
 };
+mainProcess();
 
-export { index as default, platform };
+export { main as default, platform };

package/lib/sdk/api.d.ts

@@ -68,6 +68,43 @@ declare class OneBotAPI {
         approve: boolean;
         reason?: string;
     }): Promise<any>;
+    /** 撤回消息 */
+    deleteMsg(options: {
+        message_id: number;
+    }): Promise<any>;
+    /** 上传私聊文件 */
+    uploadPrivateFile(options: {
+        user_id: number;
+        file: string;
+        name?: string;
+    }): Promise<any>;
+    /** 上传群文件 */
+    uploadGroupFile(options: {
+        group_id: number;
+        file: string;
+        name?: string;
+        folder?: string;
+    }): Promise<any>;
+    /** 发送私聊转发 */
+    sendPrivateForward(options: {
+        user_id: number;
+        messages: {
+            time?: number;
+            content: any[];
+            user_id?: string;
+            nickname?: string;
+        }[];
+    }): Promise<any>;
+    /** 发送群转发 */
+    sendGroupForward(options: {
+        group_id: number;
+        messages: {
+            time?: number;
+            content: any[];
+            user_id?: string;
+            nickname?: string;
+        }[];
+    }): Promise<any>;
 }
 
 export { OneBotAPI };

package/lib/sdk/api.js

@@ -59,8 +59,9 @@ class OneBotAPI {
      * @returns
      */
     sendPrivateMessage(options) {
-        if (!this.ws)
+        if (!this.ws) {
             return;
+        }
         return send(this.ws, {
             action: 'send_private_msg',
             params: options
@@ -72,8 +73,9 @@ class OneBotAPI {
      * @returns
      */
     sendGroupMessage(options) {
-        if (!this.ws)
+        if (!this.ws) {
             return;
+        }
         return send(this.ws, {
             action: 'send_group_msg',
             params: options
@@ -85,8 +87,9 @@ class OneBotAPI {
      * @returns
      */
     sendMessage(options) {
-        if (!this.ws)
+        if (!this.ws) {
             return;
+        }
         return send(this.ws, {
             action: 'send_msg',
             params: options
@@ -96,8 +99,9 @@ class OneBotAPI {
      * 好友列表
      */
     getFriendList() {
-        if (!this.ws)
+        if (!this.ws) {
             return;
+        }
         return send(this.ws, {
             action: 'get_friend_list',
             params: {}
@@ -107,8 +111,9 @@ class OneBotAPI {
      * 群列表
      */
     getGroupList() {
-        if (!this.ws)
+        if (!this.ws) {
             return;
+        }
         return send(this.ws, {
             action: 'get_group_list',
             params: {}
@@ -120,8 +125,9 @@ class OneBotAPI {
      * @returns
      */
     getGroupMemberList(options) {
-        if (!this.ws)
+        if (!this.ws) {
             return;
+        }
         return send(this.ws, {
             action: 'get_group_member_list',
             params: options
@@ -133,8 +139,9 @@ class OneBotAPI {
      * @returns
      */
     setFriendAddRequest(options) {
-        if (!this.ws)
+        if (!this.ws) {
             return;
+        }
         return send(this.ws, {
             action: 'set_friend_add_request',
             params: options
@@ -146,13 +153,74 @@ class OneBotAPI {
      * @returns
      */
     setGroupAddRequest(options) {
-        if (!this.ws)
+        if (!this.ws) {
             return;
+        }
         return send(this.ws, {
             action: 'set_group_add_request',
             params: options
         });
     }
+    /** 撤回消息 */
+    deleteMsg(options) {
+        if (!this.ws) {
+            return;
+        }
+        return send(this.ws, {
+            action: 'delete_msg',
+            params: options
+        });
+    }
+    /** 上传私聊文件 */
+    uploadPrivateFile(options) {
+        if (!this.ws) {
+            return;
+        }
+        return send(this.ws, {
+            action: 'upload_private_file',
+            params: options
+        });
+    }
+    /** 上传群文件 */
+    uploadGroupFile(options) {
+        if (!this.ws) {
+            return;
+        }
+        return send(this.ws, {
+            action: 'upload_group_file',
+            params: options
+        });
+    }
+    /** 发送私聊转发 */
+    sendPrivateForward(options) {
+        if (!this.ws) {
+            return;
+        }
+        return send(this.ws, {
+            action: 'send_private_forward_msg',
+            params: {
+                user_id: 80000000,
+                nickname: '匿名消息',
+                ...options,
+                messages: options.messages.map(data => ({ data, type: 'node' }))
+            }
+        });
+    }
+    /** 发送群转发 */
+    sendGroupForward(options) {
+        if (!this.ws) {
+            return;
+        }
+        return send(this.ws, {
+            action: 'send_group_forward_msg',
+            params: {
+                user_id: 80000000,
+                nickname: '匿名消息',
+                ...options,
+                messages: options.messages.map(data => ({ data, type: 'node' }))
+            }
+        });
+    }
 }
 
 export { OneBotAPI, consume };

package/lib/sdk/types.d.ts

@@ -0,0 +1,72 @@
+interface Sender {
+    user_id: number;
+    nickname: string;
+    card: string;
+    role: 'admin' | 'member';
+}
+type Message = {
+    type: 'image';
+    data: {
+        file: string;
+        sub_type: number;
+        file_id: string;
+        url: string;
+        file_size: string;
+        file_unique: string;
+    };
+} | {
+    type: 'text';
+    data: {
+        text: string;
+    };
+} | {
+    type: 'json';
+    data: string;
+} | {
+    type: 'forward';
+    data: {
+        id: number;
+        content: any[];
+    };
+};
+interface MESSAGES_TYPE {
+    self_id: number;
+    user_id: number;
+    time: number;
+    message_id: number;
+    message_seq: number;
+    real_id: number;
+    message_type: 'group';
+    sender: Sender;
+    raw_message: string;
+    font: number;
+    sub_type: 'normal';
+    message: Message[];
+    message_format: 'array';
+    post_type: 'message';
+    group_id: number;
+}
+interface DIRECT_MESSAGE_TYPE {
+    self_id: number;
+    user_id: number;
+    time: number;
+    message_id: number;
+    message_seq: number;
+    real_id: number;
+    message_type: 'private';
+    sender: {
+        user_id: 1715713638;
+        nickname: string;
+        card: '';
+    };
+    raw_message: string;
+    font: 14;
+    sub_type: 'group' | 'friend';
+    message: Message[];
+    message_format: 'array';
+    post_type: 'message';
+    group_id: number;
+    temp_source: number;
+}
+
+export type { DIRECT_MESSAGE_TYPE, MESSAGES_TYPE };

package/lib/sdk/wss.js

@@ -1,5 +1,6 @@
 import WebSocket, { WebSocketServer } from 'ws';
 import { OneBotAPI, consume } from './api.js';
+import dayjs from 'dayjs';
 
 /**
  * 连接
@@ -24,6 +25,15 @@ class OneBotClient extends OneBotAPI {
         }
     }
     #events = {};
+    // 重连次数
+    #count = 0;
+    #getReConnectTime() {
+        const time = this.#count > 3 ? 1000 * 6 : 1000 * 1;
+        const curTime = this.#count > 6 ? 1000 * this.#count * 2 : time;
+        logger.info(`[OneBot] 等待 ${dayjs(curTime).format('mm:ss')} 后重新连接`);
+        this.#count++;
+        return curTime;
+    }
     /**
      * 注册事件处理程序
      * @param key 事件名称
@@ -38,63 +48,65 @@ class OneBotClient extends OneBotAPI {
      * @param cfg
      * @param conversation
      */
-    async connect() {
+    connect() {
         const { url, access_token: token, reverse_enable, reverse_port } = this.#options;
-        const c = token == '' || !token
+        const notToken = !token || token === '';
+        const c = notToken
             ? {}
             : {
                 headers: {
                     ['Authorization']: `Bearer ${token}`
                 }
             };
-        const onMessage = async (data) => {
+        const onMessage = data => {
             try {
                 const event = JSON.parse(data.toString());
                 if (!event) {
-                    if (this.#events['ERROR'])
-                        this.#events['ERROR'](event);
-                    return;
+                    logger.error('[OneBot] WebSocket message is empty');
                 }
-                else if (event?.post_type == 'meta_event') {
-                    if (this.#events['META'])
+                else if (event?.post_type === 'meta_event') {
+                    if (this.#events['META']) {
                         this.#events['META'](event);
-                    return;
+                    }
                 }
-                else if (event?.post_type == 'message') {
-                    if (event?.message_type == 'group') {
-                        if (this.#events['MESSAGES'])
+                else if (event?.post_type === 'message') {
+                    if (event?.message_type === 'group') {
+                        if (this.#events['MESSAGES']) {
                             this.#events['MESSAGES'](event);
+                        }
                     }
-                    else if (event?.message_type == 'private') {
-                        if (this.#events['DIRECT_MESSAGE'])
+                    else if (event?.message_type === 'private') {
+                        if (this.#events['DIRECT_MESSAGE']) {
                             this.#events['DIRECT_MESSAGE'](event);
+                        }
                     }
-                    return;
                 }
-                else if (event?.post_type == 'notice') {
-                    if (event?.notice_type == 'group_increase') {
+                else if (event?.post_type === 'notice') {
+                    if (event?.notice_type === 'group_increase') {
                         // 群成员增加
-                        if (this.#events['NOTICE_GROUP_MEMBER_INCREASE'])
+                        if (this.#events['NOTICE_GROUP_MEMBER_INCREASE']) {
                             this.#events['NOTICE_GROUP_MEMBER_INCREASE'](event);
+                        }
                     }
-                    else if (event?.notice_type == 'group_decrease') {
+                    else if (event?.notice_type === 'group_decrease') {
                         // 群成员减少
-                        if (this.#events['NOTICE_GROUP_MEMBER_REDUCE'])
+                        if (this.#events['NOTICE_GROUP_MEMBER_REDUCE']) {
                             this.#events['NOTICE_GROUP_MEMBER_REDUCE'](event);
+                        }
                     }
-                    return;
                 }
-                else if (event?.post_type == 'request') {
+                else if (event?.post_type === 'request') {
                     // 收到加群 或 加好友的请求。
-                    if (event?.request_type == 'friend') {
-                        if (this.#events['REQUEST_ADD_FRIEND'])
+                    if (event?.request_type === 'friend') {
+                        if (this.#events['REQUEST_ADD_FRIEND']) {
                             this.#events['REQUEST_ADD_FRIEND'](event);
+                        }
                     }
-                    else if (event?.request_type == 'group') {
-                        if (this.#events['REQUEST_ADD_GROUP'])
+                    else if (event?.request_type === 'group') {
+                        if (this.#events['REQUEST_ADD_GROUP']) {
                             this.#events['REQUEST_ADD_GROUP'](event);
+                        }
                     }
-                    return;
                 }
                 else if (event?.echo) {
                     // 消费
@@ -102,16 +114,18 @@ class OneBotClient extends OneBotAPI {
                 }
             }
             catch (err) {
-                if (this.#events['ERROR'])
-                    this.#events['ERROR'](err);
+                logger.error('[OneBot] WebSocket error: ', err);
             }
         };
         const onClose = (code, reason) => {
-            if (this.#events['ERROR'])
-                this.#events['ERROR']({
-                    de: code,
-                    reason: reason.toString('utf8')
-                });
+            logger.error(`[OneBot] WebSocket closed: ${code} - ${reason.toString('utf8')}`);
+            if (reverse_enable) {
+                return;
+            }
+            const curTime = this.#getReConnectTime();
+            setTimeout(() => {
+                this.connect();
+            }, curTime);
         };
         if (!this.ws) {
             if (reverse_enable) {
@@ -123,14 +137,15 @@ class OneBotClient extends OneBotAPI {
                     this.ws.on('message', onMessage);
                     // close
                     this.ws.on('close', onClose);
-                    console.info('connected: ws://127.0.0.1:' + reverse_port);
+                    logger.info(`[OneBot] connected: ws://127.0.0.1:${reverse_port}`);
                 });
             }
             else {
                 // forward_open
                 this.ws = new WebSocket(url, c);
                 this.ws.on('open', () => {
-                    console.debug(`open:${url}`);
+                    logger.info(`[OneBot] connected: ${url}`);
+                    this.#count = 0;
                 });
                 // message
                 this.ws.on('message', onMessage);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alemonjs/onebot",
-  "version": "2.1.0-alpha.0",
+  "version": "2.1.0-alpha.10",
   "description": "onebot v11",
   "author": "lemonade",
   "license": "MIT",
@@ -21,8 +21,12 @@
     "alemonjs"
   ],
   "dependencies": {
+    "dayjs": "^1.11.13",
     "ws": "^8.18.1"
   },
+  "peerDependencies": {
+    "alemonjs": "^2.1.0-alpha.15"
+  },
   "alemonjs": {
     "desktop": {
       "platform": [