cyberbot-next/src/event.js

cyberbot, 基于napcat-ts, nodejs，轻量qq机器人框架。

import { Structs } from "./types.js";
import { logger } from "./logger.js";
import { createHash } from 'crypto';
export const createEventHandlers = (napcat, config) => {
    const reply = async (context, content, quote = false) => {
        try {
            const messageElements = (Array.isArray(content) ? content : [content])
                .map(item => typeof item === 'string' || typeof item === 'number' ? Structs.text(String(item)) : item);
            if (quote && context.message_id) {
                messageElements.unshift(Structs.reply(context.message_id));
            }
            if (context.group_id) {
                return await napcat.send_group_msg({ group_id: context.group_id, message: messageElements });
            }
            else if (context.user_id) {
                return await napcat.send_private_msg({ user_id: context.user_id, message: messageElements });
            }
            logger.error('无法回复消息：消息上下文缺少必要信息');
            return { message_id: 0 };
        }
        catch (error) {
            logger.error('发送消息失败:', error);
            return { message_id: 0 };
        }
    };
    const sendPrivateMessage = async (userId, content) => {
        try {
            const messageElements = (Array.isArray(content) ? content : [content])
                .map(item => typeof item === 'string' || typeof item === 'number' ? Structs.text(String(item)) : item);
            return await napcat.send_private_msg({
                user_id: userId,
                message: messageElements
            });
        }
        catch (error) {
            logger.error(`发送私聊消息给用户 ${userId} 失败:`, error);
            return { message_id: 0 };
        }
    };
    const sendGroupMessage = async (groupId, content) => {
        try {
            const messageElements = (Array.isArray(content) ? content : [content])
                .map(item => typeof item === 'string' || typeof item === 'number' ? Structs.text(String(item)) : item);
            return await napcat.send_group_msg({
                group_id: groupId,
                message: messageElements
            });
        }
        catch (error) {
            logger.error(`发送群聊消息给群 ${groupId} 失败:`, error);
            return { message_id: 0 };
        }
    };
    const isMaster = async (id) => {
        if (typeof id === 'number' && !isNaN(id)) {
            return config.master === id;
        }
        return false;
    };
    const isAdmin = async (id) => {
        return config.admins.includes(id);
    };
    const hasRight = async (user_id) => {
        return isMaster(user_id) || isAdmin(user_id);
    };
    const delete_msg = async (message_id) => {
        try {
            await napcat.delete_msg({ message_id });
        }
        catch (error) {
            logger.error(`Failed to delete message: ${error}`);
        }
    };
    const kick = async (group_id, user_id, reject_add_request = false) => {
        try {
            await napcat.set_group_kick({ group_id, user_id, reject_add_request });
        }
        catch (error) {
            logger.error(`Failed to kick user ${user_id} from group ${group_id}: ${error}`);
        }
    };
    const ban = async (group_id, user_id, duration) => {
        try {
            await napcat.set_group_ban({ group_id, user_id, duration });
        }
        catch (error) {
            logger.error(`Failed to ban user ${user_id} from group ${group_id}: ${error}`);
        }
    };
    const banAll = async (group_id, enable) => {
        try {
            await napcat.set_group_whole_ban({ group_id, enable });
        }
        catch (error) {
            logger.error(`Failed to ban all users from group ${group_id}: ${error}`);
        }
    };
    const setGroupName = async (group_id, name) => {
        try {
            await napcat.set_group_name({ group_id, group_name: name });
        }
        catch (error) {
            logger.error(`Failed to set group name ${name} for group ${group_id}: ${error}`);
        }
    };
    const setAdmin = async (group_id, user_id, enable) => {
        try {
            await napcat.set_group_admin({ group_id, user_id, enable });
        }
        catch (error) {
            logger.error(`Failed to set admin ${user_id} for group ${group_id}: ${error}`);
        }
    };
    const setTitle = async (group_id, user_id, title) => {
        try {
            await napcat.set_group_special_title({ group_id, user_id, special_title: title });
        }
        catch (error) {
            logger.error(`Failed to set title ${title} for user ${user_id} in group ${group_id}: ${error}`);
        }
    };
    const aprroveGroup = async (flag) => {
        try {
            await napcat.set_group_add_request({
                flag: flag,
                approve: true
            });
        }
        catch (error) {
            logger.error(`Failed to approve group request: ${error}`);
        }
    };
    const rejectGroup = async (flag) => {
        try {
            await napcat.set_group_add_request({
                flag: flag,
                approve: false
            });
        }
        catch (error) {
            logger.error(`Failed to reject group request: ${error}`);
        }
    };
    const isGroupAdmin = async (group_id, user_id) => {
        try {
            const memberInfo = await napcat.get_group_member_info({ group_id, user_id });
            return memberInfo.role === 'admin' || memberInfo.role === 'owner';
        }
        catch (error) {
            logger.error(`Failed to check if user ${user_id} is an admin in group ${group_id}: ${error}`);
            return false;
        }
    };
    const isGroupOwner = async (group_id, user_id) => {
        try {
            const memberInfo = await napcat.get_group_member_info({ group_id, user_id });
            return memberInfo.role === 'owner';
        }
        catch (error) {
            logger.error(`Failed to check if user ${user_id} is the owner of group ${group_id}: ${error}`);
            return false;
        }
    };
    const md5 = (text) => {
        return createHash('md5').update(text).digest('hex');
    };
    const randomInt = (min, max) => {
        return Math.floor(Math.random() * (max - min + 1)) + min;
    };
    const randomItem = (array) => {
        return array[Math.floor(Math.random() * array.length)];
    };
    const getGroupAvatarLink = (group_id, size) => {
        return `https://p.qlogo.cn/gh/${group_id}/${group_id}/${size || 100}`;
    };
    const getQQAvatarLink = (user_id, size) => {
        return `https://q2.qlogo.cn/headimg_dl?dst_uin=${user_id}&spec=${size || 40}`;
    };
    const getImageLink = (raw_message) => {
        try {
            const imagePattern = /\[CQ:image,.*?url=(.*?),/g;
            const match = imagePattern.exec(raw_message);
            if (match && match[1]) {
                return match[1];
            }
            else {
                logger.warn('未找到图片链接');
                return "";
            }
        }
        catch (error) {
            logger.error('提取图片链接时发生错误:', error);
            return "";
        }
    };
    const getDirectLink = async (url) => {
        try {
            const rKey = await napcat.nc_get_rkey();
            if (!rKey) {
                logger.error('获取 rkey 失败，无法替换');
                return "";
            }
            const appidMatch = url.match(/appid=(\d+)/);
            const appid = appidMatch ? appidMatch[1] : null;
            let current_rkey;
            if (appid === '1406') {
                current_rkey = rKey[0]?.rkey;
            }
            else if (appid === '1407') {
                current_rkey = rKey[1]?.rkey;
            }
            else {
                logger.error('未知的appid或无法从URL中提取appid');
                return "";
            }
            const regex = /^(.*?)&rkey=/;
            const baseUrl = url.match(regex)?.[1];
            return baseUrl ? `${baseUrl}${current_rkey}` : "";
        }
        catch (error) {
            logger.error('获取直链失败:', error);
            return "";
        }
    };
    const getMessageId = (raw_message) => {
        try {
            const regex = /\[CQ:reply,id=(\d+)\]/;
            const match = raw_message.match(regex);
            if (match && match[1]) {
                return match[1];
            }
            return "";
        }
        catch (error) {
            logger.error('提取消息ID时发生错误:', error);
            return "";
        }
    };
    const getMessageAt = (raw_message) => {
        try {
            const regex = /\[CQ:at,qq=(\d+)\]/g;
            const matches = raw_message.matchAll(regex);
            const qqs = [];
            for (const match of matches) {
                if (match[1]) {
                    qqs.push(Number(match[1]));
                }
            }
            return qqs;
        }
        catch (error) {
            logger.error('提取消息ID时发生错误:', error);
            return [];
        }
    };
    const getText = (raw_message) => {
        try {
            const cqCodePattern = /\[CQ:[^\]]+\]/g;
            return raw_message.replace(cqCodePattern, '').trim();
        }
        catch (error) {
            logger.error('提取纯文本内容时发生错误:', error);
            return "";
        }
    };
    const getQuotedText = async (raw_message) => {
        try {
            const regex = /\[CQ:reply,id=(\d+)\]/;
            const match = raw_message.match(regex);
            if (match && match[1]) {
                const message = await napcat.get_msg({ message_id: Number(match[1]) });
                return message.raw_message;
            }
            return "";
        }
        catch (error) {
            logger.error('提取被引用的文本时发生错误:', error);
            return "";
        }
    };
    const fakeMessage = async (target_id, message, isGroup) => {
        try {
            const params = isGroup
                ? { group_id: target_id, message: message }
                : { user_id: target_id, message: message };
            return await napcat.send_forward_msg(params);
        }
        catch (error) {
            logger.error(`Failed to send fake message to target ${target_id}: ${error}`);
            throw error;
        }
    };
    return {
        reply,
        sendPrivateMessage,
        sendGroupMessage,
        isMaster,
        isAdmin,
        hasRight,
        delete_msg,
        kick,
        ban,
        banAll,
        setGroupName,
        setAdmin,
        setTitle,
        aprroveGroup,
        rejectGroup,
        isGroupAdmin,
        isGroupOwner,
        md5,
        randomInt,
        randomItem,
        getGroupAvatarLink,
        getQQAvatarLink,
        getImageLink,
        getDirectLink,
        getMessageId,
        getMessageAt,
        getText,
        getQuotedText,
        fakeMessage
    };
};
//# sourceMappingURL=event.js.map