onebots 0.4.22 → 0.4.25

package/lib/adapters/qq/qqBot.js

@@ -0,0 +1,438 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QQBot = void 0;
+const axios_1 = __importDefault(require("axios"));
+const log4js = __importStar(require("log4js"));
+const events_1 = require("events");
+const sessionManager_1 = require("./sessionManager");
+const message_1 = require("./message");
+const event_1 = require("./event");
+const onebot_1 = require("../../onebot");
+var UnsupportedMethodError = onebot_1.OneBot.UnsupportedMethodError;
+class QQBot extends events_1.EventEmitter {
+    constructor(config) {
+        var _a;
+        super();
+        this.config = config;
+        this.sessionManager = new sessionManager_1.SessionManager(this);
+        this.request = axios_1.default.create({
+            baseURL: this.config.sandbox ? 'https://sandbox.api.sgroup.qq.com' : `https://api.sgroup.qq.com`,
+            timeout: 5000,
+            headers: {
+                'User-Agent': `BotNodeSDK/0.0.1`
+            }
+        });
+        this.request.interceptors.request.use((config) => {
+            config.headers['Authorization'] = `QQBot ${this.sessionManager.access_token}`;
+            config.headers['X-Union-Appid'] = this.config.appid;
+            if (config['rest']) {
+                const restObj = config['rest'];
+                delete config['rest'];
+                for (const key in restObj) {
+                    config.url = config.url.replace(':' + key, restObj[key]);
+                }
+            }
+            return config;
+        });
+        this.logger = log4js.getLogger(`[QQBot:${this.config.appid}]`);
+        this.logger.level = (_a = this.config).logLevel || (_a.logLevel = 'info');
+    }
+    removeAt(payload) {
+        const reg = new RegExp(`<@!${this.self_id}>`);
+        const isAtMe = reg.test(payload.content) && payload.mentions.some(mention => mention.id === this.self_id);
+        if (!isAtMe)
+            return;
+        payload.content = payload.content.replace(reg, '').trimStart();
+    }
+    processPayload(event_id, event, payload) {
+        let [post_type, ...sub_type] = event.split('.');
+        const result = {
+            event_id,
+            post_type,
+            [`${post_type}_type`]: sub_type.join('.'),
+            ...payload
+        };
+        if (['message.group', 'message.private', 'message.guild', 'message.direct'].includes(event)) {
+            this.removeAt(payload);
+            const [message, brief] = message_1.Message.parse.call(this, payload);
+            result.message = message;
+            Object.assign(result, {
+                user_id: payload.author?.id,
+                message_id: payload.event_id || payload.id,
+                raw_message: brief,
+                sender: {
+                    user_id: payload.author?.id,
+                    user_openid: payload.author?.user_openid || payload.author?.member_openid
+                },
+                timestamp: new Date(payload.timestamp).getTime() / 1000,
+            });
+            let messageEvent;
+            switch (event) {
+                case 'message.private':
+                    messageEvent = new message_1.PrivateMessageEvent(this, result);
+                    this.logger.info(`recv from User(${result.user_id}): ${result.raw_message}`);
+                    break;
+                case 'message.group':
+                    messageEvent = new message_1.GroupMessageEvent(this, result);
+                    this.logger.info(`recv from Group(${result.group_id}): ${result.raw_message}`);
+                    break;
+                case 'message.guild':
+                    messageEvent = new message_1.GuildMessageEvent(this, result);
+                    this.logger.info(`recv from Guild(${result.guild_id})Channel(${result.channel_id}): ${result.raw_message}`);
+                    break;
+                case 'message.direct':
+                    messageEvent = new message_1.DirectMessageEvent(this, result);
+                    this.logger.info(`recv from Direct(${result.guild_id}): ${result.raw_message}`);
+                    break;
+            }
+            return messageEvent;
+        }
+        return result;
+    }
+    async getSelfInfo() {
+        const { data: result } = await this.request.get('/users/@me');
+        return result;
+    }
+    async getChannelPermissionOfRole(channel_id, role_id) {
+        const { data: result } = await this.request.get(`/channels/${channel_id}/roles/${role_id}/permissions`);
+        return result;
+    }
+    async setChannelAnnounce(guild_id, channel_id, message_id) {
+        const { data: result } = await this.request.post(`/guilds/${guild_id}/announces`, {
+            message_id,
+            channel_id
+        });
+        return result;
+    }
+    async updateChannelPermissionOfRole(channel_id, role_id, permission) {
+        const result = await this.request.put(`/channels/${channel_id}/roles/${role_id}/permissions`, permission);
+        return result.status === 204;
+    }
+    async getChannelMemberPermission(channel_id, member_id) {
+        const { data: result } = await this.request.get(`/channels/${channel_id}/members/${member_id}/permissions`);
+        return result;
+    }
+    async updateChannelMemberPermission(channel_id, member_id, permission) {
+        const result = await this.request.put(`/channels/${channel_id}/members/${member_id}/permissions`, permission);
+        return result.status === 204;
+    }
+    async getChannelPins(channel_id) {
+        const { data: { message_ids = [] } = {} } = await this.request.get(`/channels/${channel_id}/pins`);
+        return message_ids;
+    }
+    async pinChannelMessage(channel_id, message_id) {
+        const { data: result } = await this.request.post(`/channels/${channel_id}/pins/${message_id}`);
+        return result;
+    }
+    async unPinChannelMessage(channel_id, message_id) {
+        const { data: result } = await this.request.delete(`/channels/${channel_id}/pins/${message_id}`);
+        return result;
+    }
+    async createChannel(guild_id, channelInfo) {
+        const { data: result } = await this.request.post(`/guilds/${guild_id}/channels`, channelInfo);
+        return result;
+    }
+    async updateChannel({ channel_id, ...updateInfo }) {
+        const { data: result } = await this.request.patch(`/channels/${channel_id}`, updateInfo);
+        return result;
+    }
+    async deleteChannel(channel_id) {
+        const result = await this.request.delete(`/channels/${channel_id}`);
+        return result.status === 200;
+    }
+    async getGuildRoles(guild_id) {
+        const { data: { roles = [] } = {} } = await this.request.get(`/guilds/${guild_id}/roles`);
+        return roles;
+    }
+    async creatGuildRole(guild_id, role) {
+        const { data: result } = await this.request.post(`/guilds/${guild_id}/roles`, role);
+        return result.role;
+    }
+    async updateGuildRole(guild_id, { id, ...role }) {
+        const { data: result } = await this.request.patch(`/guilds/${guild_id}/roles/${id}`, role);
+        return result.role;
+    }
+    async deleteGuildRole(role_id) {
+        const result = await this.request.delete(`/guilds/{guild_id}/roles/${role_id}`);
+        return result.status === 204;
+    }
+    async getGuildAccessApis(guild_id) {
+        const { data: result } = await this.request.get(`/guilds/${guild_id}/api_permission`);
+        return result.apis || [];
+    }
+    async applyGuildAccess(guild_id, channel_id, apiInfo, desc) {
+        const { data: result } = await this.request.post(`/guilds/${guild_id}/api_permission/demand`, {
+            channel_id,
+            api_identify: apiInfo,
+            desc,
+        });
+        return result;
+    }
+    async unMuteGuild(guild_id) {
+        return this.muteGuild(guild_id, 0, 0);
+    }
+    async muteGuild(guild_id, seconds, end_time) {
+        const result = await this.request.put(`/guilds/${guild_id}/mute`, {
+            mute_seconds: `${seconds}`,
+            mute_end_timestamp: `${end_time}`
+        });
+        return result.status === 204;
+    }
+    async unMuteGuildMembers(guild_id, member_ids) {
+        return this.muteGuildMembers(guild_id, member_ids, 0, 0);
+    }
+    async muteGuildMembers(guild_id, member_ids, seconds, end_time) {
+        const result = await this.request.put(`/guilds/${guild_id}/mute`, {
+            mute_seconds: `${seconds}`,
+            mute_end_timestamp: `${end_time}`,
+            user_ids: member_ids
+        });
+        return result.status === 200;
+    }
+    async addGuildMemberRoles(guild_id, channel_id, member_id, role_id) {
+        const result = await this.request.put(`/guilds/${guild_id}/members/${member_id}/roles/${role_id}`, { id: channel_id });
+        return result.status === 204;
+    }
+    async removeGuildMemberRoles(guild_id, channel_id, member_id, role_id) {
+        const result = await this.request.delete(`/guilds/${guild_id}/members/${member_id}/roles/${role_id}`, { data: { id: channel_id } });
+        return result.status === 204;
+    }
+    async kickGuildMember(guild_id, member_id, clean = 0, blacklist) {
+        const result = await this.request.delete(`/guilds/${guild_id}/members/${member_id}`, { data: {
+                add_blacklist: blacklist,
+                delete_message_days: clean
+            } });
+        return result.status === 204;
+    }
+    async unMuteGuildMember(guild_id, member_id) {
+        return this.muteGuildMember(guild_id, member_id, 0, 0);
+    }
+    async muteGuildMember(guild_id, member_id, seconds, end_time) {
+        const result = await this.request.put(`/guilds/${guild_id}/members/${member_id}/mute`, {
+            mute_seconds: `${seconds}`,
+            mute_end_timestamp: `${end_time}`
+        });
+        return result.status === 204;
+    }
+    async getGuildList() {
+        const _getGuildList = async (after = undefined) => {
+            const res = await this.request.get('/users/@me/guilds', {
+                params: {
+                    after
+                }
+            }).catch(() => ({ data: [] })); // 私域不支持获取频道列表，做个兼容
+            if (!res.data?.length)
+                return [];
+            const result = (res.data || []).map(g => {
+                const { joined_at, ...guild } = g;
+                return {
+                    join_time: new Date(joined_at).getTime() / 1000,
+                    ...guild
+                };
+            });
+            const last = result[result.length - 1];
+            return [...result, ...await _getGuildList(last.id)];
+        };
+        return await _getGuildList();
+    }
+    async getGuildMemberList(guild_id) {
+        const _getGuildMemberList = async (after = undefined) => {
+            const res = await this.request.get(`/guilds/${guild_id}/members`, {
+                params: {
+                    after,
+                    limit: 100
+                }
+            }).catch(() => ({ data: [] })); // 公域没有权限，做个兼容
+            if (!res.data?.length)
+                return [];
+            const result = (res.data || []).map(m => {
+                const { id: member_id, role, join_time, ...member } = m;
+                return {
+                    member_id,
+                    role,
+                    join_time: new Date(join_time).getTime() / 1000,
+                    ...member
+                };
+            });
+            const last = result[result.length - 1];
+            return [...result, ...await _getGuildMemberList(last.user?.id)];
+        };
+        return await _getGuildMemberList();
+    }
+    async getGuildMemberInfo(guild_id, member_id) {
+        const { data: result } = await this.request.get(`/guilds/${guild_id}/members/${member_id}`);
+        return result;
+    }
+    async getChannelInfo(channel_id) {
+        const { data: result } = await this.request.get(`/channels/${channel_id}`);
+        return result;
+    }
+    async getGroupMemberList(group_id) {
+        throw UnsupportedMethodError;
+    }
+    async getGroupMemberInfo(group_id, member_id) {
+        throw UnsupportedMethodError;
+    }
+    async getFriendList() {
+        throw UnsupportedMethodError;
+    }
+    async getFriendInfo(friend_id) {
+        throw UnsupportedMethodError;
+    }
+    async getChannelList(guild_id) {
+        const { data: result = [] } = await this.request.get(`/guilds/${guild_id}/channels`);
+        return result;
+    }
+    async sendPrivateMessage(user_id, message, source) {
+        const { hasMessages, messages, brief, hasFiles, files } = await message_1.Message.format.call(this, message, source);
+        let message_id = '';
+        if (hasMessages) {
+            let { data: { id } } = await this.request.post(`/v2/users/${user_id}/messages`, messages);
+            message_id = id;
+        }
+        if (hasFiles) {
+            let { data: { id } } = await this.request.post(`/v2/users/${user_id}/files`, files);
+            if (message_id)
+                message_id = `${message_id}|`;
+            message_id = message_id + id;
+        }
+        this.logger.info(`send to User(${user_id}): ${brief}`);
+        return {
+            message_id,
+            timestamp: new Date().getTime() / 1000
+        };
+    }
+    async createDirectSession(guild_id, user_id) {
+        const { data: result } = await this.request.post(`/users/@me/dms`, {
+            recipient_id: user_id,
+            source_guild_id: guild_id
+        });
+        return result;
+    }
+    async sendDirectMessage(guild_id, message, source) {
+        const { hasMessages, messages, brief, hasFiles, files } = await message_1.Message.format.call(this, message, source);
+        let message_id = '';
+        if (hasMessages) {
+            let { data: { id } } = await this.request.post(`/dms/${guild_id}/messages`, messages);
+            message_id = id;
+        }
+        if (hasFiles) {
+            let { data: { id } } = await this.request.post(`/dms/${guild_id}/files`, files);
+            if (message_id)
+                message_id = `${message_id}|`;
+            message_id = message_id + id;
+        }
+        this.logger.info(`send to Direct(${guild_id}): ${brief}`);
+        return {
+            message_id,
+            timestamp: new Date().getTime() / 1000
+        };
+    }
+    async sendGuildMessage(channel_id, message, source) {
+        const { hasMessages, messages, brief, hasFiles, files } = await message_1.Message.format.call(this, message, source);
+        let message_id = '';
+        if (hasMessages) {
+            let { data: { id } } = await this.request.post(`/channels/${channel_id}/messages`, messages);
+            message_id = id;
+        }
+        if (hasFiles) {
+            console.log(files);
+            let { data: { id } } = await this.request.post(`/channels/${channel_id}/files`, files);
+            if (message_id)
+                message_id = `${message_id}|`;
+            message_id = message_id + id;
+        }
+        this.logger.info(`send to Channel(${channel_id}): ${brief}`);
+        return {
+            message_id,
+            timestamp: new Date().getTime() / 1000
+        };
+    }
+    async sendGroupMessage(group_id, message, source) {
+        const { hasMessages, messages, brief, hasFiles, files } = await message_1.Message.format.call(this, message, source);
+        let message_id = '';
+        if (hasMessages) {
+            const { data: result } = await this.request.post(`/v2/groups/${group_id}/messages`, messages);
+            console.log(result);
+            message_id = result.seq;
+        }
+        if (hasFiles) {
+            let { data: { id } } = await this.request.post(`/v2/groups/${group_id}/files`, files);
+            if (message_id)
+                message_id = `${message_id}|`;
+            message_id = message_id + id;
+        }
+        this.logger.info(`send to Group(${group_id}): ${brief}`);
+        return {
+            message_id,
+            timestamp: new Date().getTime() / 1000
+        };
+    }
+    dispatchEvent(event, wsRes) {
+        this.logger.debug(event, wsRes);
+        const payload = wsRes.d;
+        const event_id = wsRes.id || '';
+        if (!payload || !event)
+            return;
+        const transformEvent = event_1.QQEvent[event] || 'system';
+        this.em(transformEvent, this.processPayload(event_id, transformEvent, payload));
+    }
+    em(event, payload) {
+        const eventNames = event.split('.');
+        const [post_type, detail_type, ...sub_type] = eventNames;
+        Object.assign(payload, {
+            post_type,
+            [`${post_type}_type`]: detail_type,
+            sub_type: sub_type.join('.'),
+            ...payload
+        });
+        let prefix = '';
+        while (eventNames.length) {
+            let fullEventName = `${prefix}.${eventNames.shift()}`;
+            if (fullEventName.startsWith('.'))
+                fullEventName = fullEventName.slice(1);
+            this.emit(fullEventName, payload);
+            prefix = fullEventName;
+        }
+    }
+}
+exports.QQBot = QQBot;
+(function (QQBot) {
+    function getFullTargetId(message) {
+        switch (message.sub_type) {
+            case "private":
+                return message.user_id;
+            case "group":
+                return `${message.group_id}:${message.user_id}`;
+            case "guild":
+                return `${message.guild_id}:${message.channel_id}:${message.user_id}`;
+        }
+    }
+    QQBot.getFullTargetId = getFullTargetId;
+})(QQBot || (exports.QQBot = QQBot = {}));

package/lib/adapters/qq/sessionManager.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { QQBot } from "./qqBot";
+import { EventEmitter } from "events";
+import { OpCode } from "./constans";
+export declare const MAX_RETRY = 10;
+export declare class SessionManager extends EventEmitter {
+    private bot;
+    access_token: string;
+    wsUrl: string;
+    retry: number;
+    alive?: boolean;
+    heartbeatInterval: number;
+    isReconnect: boolean;
+    sessionRecord: {
+        sessionID: string;
+        seq: number;
+    };
+    heartbeatParam: {
+        op: OpCode;
+        d: any;
+    };
+    get token(): string;
+    constructor(bot: QQBot);
+    getAccessToken(): Promise<QQBot.Token>;
+    getWsUrl(): Promise<void>;
+    getValidIntends(): number;
+    start(): Promise<void>;
+    connect(): void;
+    reconnectWs(): void;
+    sendWs(msg: unknown): void;
+    authWs(): void;
+    startListen(): void;
+}