onebots 0.4.23 → 0.4.25

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

@@ -0,0 +1,83 @@
+import { MessageElem, Quotable, Sendable } from "./elements";
+import { QQBot } from "./qqBot";
+import { Dict } from "./types";
+import { Bot } from "./bot";
+export declare class Message {
+    bot: Bot;
+    sub_type: Message.SubType;
+    get self_id(): string;
+    guild_id?: string;
+    channel_id?: string;
+    group_id?: string;
+    message_id: string;
+    sender: Message.Sender;
+    user_id: string;
+    constructor(bot: Bot, attrs: Partial<Message>);
+    raw_message: string;
+    message_reference?: {
+        message_id: string;
+    };
+    message: Sendable;
+    get [Symbol.unscopables](): {
+        bot: boolean;
+    };
+    toJSON(): {
+        [k: string]: any;
+    };
+}
+export interface MessageEvent {
+    reply(message: Sendable, quote?: boolean): Promise<any>;
+}
+export declare class PrivateMessageEvent extends Message implements MessageEvent {
+    constructor(bot: Bot, payload: Partial<Message>);
+    reply(message: Sendable): Promise<{
+        message_id: string;
+        timestamp: number;
+    }>;
+}
+export declare class GroupMessageEvent extends Message implements MessageEvent {
+    group_id: string;
+    group_name: string;
+    constructor(bot: Bot, payload: Partial<Message>);
+    reply(message: Sendable): Promise<{
+        message_id: string;
+        timestamp: number;
+    }>;
+}
+export declare class DirectMessageEvent extends Message implements MessageEvent {
+    user_id: string;
+    channel_id: string;
+    constructor(bot: Bot, payload: Partial<Message>);
+    reply(message: Sendable): Promise<{
+        message_id: string;
+        timestamp: number;
+    }>;
+}
+export declare class GuildMessageEvent extends Message implements MessageEvent {
+    guild_id: string;
+    guild_name: string;
+    channel_id: string;
+    channel_name: string;
+    constructor(bot: Bot, payload: Partial<Message>);
+    asAnnounce(): Promise<any>;
+    pin(): Promise<any>;
+    reply(message: Sendable): Promise<{
+        message_id: string;
+        timestamp: number;
+    }>;
+}
+export declare namespace Message {
+    interface Sender {
+        user_id: string;
+        user_name: string;
+    }
+    type SubType = 'private' | 'group' | 'guild' | 'direct';
+    function parse(this: QQBot, payload: Dict): (string | MessageElem[])[];
+    function format(this: QQBot, message: Sendable, source?: Quotable): Promise<{
+        messages: Dict;
+        hasFiles: boolean;
+        hasMessages: boolean;
+        brief: string;
+        files: Dict;
+    }>;
+}

package/lib/adapters/qq/message.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildMessageEvent = exports.DirectMessageEvent = exports.GroupMessageEvent = exports.PrivateMessageEvent = exports.Message = void 0;
+const qqBot_1 = require("./qqBot");
+const utils_1 = require("./utils");
+const crypto_1 = require("crypto");
+class Message {
+    get self_id() {
+        return this.bot.self_id;
+    }
+    constructor(bot, attrs) {
+        this.bot = bot;
+        Object.assign(this, attrs);
+    }
+    get [Symbol.unscopables]() {
+        return {
+            bot: true
+        };
+    }
+    toJSON() {
+        return Object.fromEntries(Object.keys(this)
+            .filter(key => {
+            return typeof this[key] !== "function" && !(this[key] instanceof qqBot_1.QQBot);
+        })
+            .map(key => [key, this[key]]));
+    }
+}
+exports.Message = Message;
+class PrivateMessageEvent extends Message {
+    constructor(bot, payload) {
+        super(bot, payload);
+        this.sub_type = 'private';
+    }
+    async reply(message) {
+        return this.bot.sendPrivateMessage(this.user_id, message, this);
+    }
+}
+exports.PrivateMessageEvent = PrivateMessageEvent;
+class GroupMessageEvent extends Message {
+    constructor(bot, payload) {
+        super(bot, payload);
+        this.sub_type = 'group';
+    }
+    async reply(message) {
+        return this.bot.sendGroupMessage(this.group_id, message, this);
+    }
+}
+exports.GroupMessageEvent = GroupMessageEvent;
+class DirectMessageEvent extends Message {
+    constructor(bot, payload) {
+        super(bot, payload);
+        this.sub_type = 'direct';
+    }
+    reply(message) {
+        return this.bot.sendDirectMessage(this.guild_id, message, this);
+    }
+}
+exports.DirectMessageEvent = DirectMessageEvent;
+class GuildMessageEvent extends Message {
+    constructor(bot, payload) {
+        super(bot, payload);
+        this.sub_type = 'guild';
+    }
+    async asAnnounce() {
+        return this.bot.setChannelAnnounce(this.guild_id, this.channel_id, this.message_id);
+    }
+    async pin() {
+        return this.bot.pinChannelMessage(this.channel_id, this.message_id);
+    }
+    async reply(message) {
+        return this.bot.sendGuildMessage(this.channel_id, message, this);
+    }
+}
+exports.GuildMessageEvent = GuildMessageEvent;
+(function (Message) {
+    function parse(payload) {
+        let template = payload.content || '';
+        let result = [];
+        let brief = '';
+        // 1. 处理文字表情混排
+        const regex = /("[^"]*?"|'[^']*?'|`[^`]*?`|“[^”]*?”|‘[^’]*?’|<[^>]+?>)/;
+        while (template.length) {
+            const [match] = template.match(regex) || [];
+            if (!match)
+                break;
+            const index = template.indexOf(match);
+            const prevText = template.slice(0, index);
+            if (prevText) {
+                result.push({
+                    type: 'text',
+                    text: prevText
+                });
+                brief += prevText;
+            }
+            template = template.slice(index + match.length);
+            if (match.startsWith('<')) {
+                let [type, ...attrs] = match.slice(1, -1).split(',');
+                if (type.startsWith('faceType')) {
+                    type = 'face';
+                    attrs = attrs.map((attr) => attr.replace('faceId', 'id'));
+                }
+                else if (type.startsWith('@')) {
+                    if (type.startsWith('@!')) {
+                        const id = type.slice(2);
+                        type = 'at';
+                        attrs = Object.entries(payload.mentions.find((u) => u.id === id) || {})
+                            .map(([key, value]) => `${key}=${value}`);
+                    }
+                    else if (type === '@everyone') {
+                        type = 'at';
+                        attrs = [['all', true]];
+                    }
+                }
+                else if (/^[a-z]+:[0-9]+$/.test(type)) {
+                    attrs = [['id', type.split(':')[1]]];
+                    type = 'face';
+                }
+                result.push({
+                    type,
+                    ...Object.fromEntries(attrs.map((attr) => {
+                        const [key, ...values] = attr.split('=');
+                        return [key.toLowerCase(), (0, utils_1.trimQuote)(values.join('='))];
+                    }))
+                });
+                brief += `<${type}:${attrs.join(',')}>`;
+            }
+        }
+        if (template) {
+            result.push({
+                type: 'text',
+                text: template
+            });
+            brief += template;
+        }
+        // 2. 将附件添加到消息中
+        if (payload.attachments) {
+            for (const attachment of payload.attachments) {
+                let { content_type, ...data } = attachment;
+                const [type] = content_type.split('/');
+                result.push({
+                    type,
+                    ...data,
+                    src: data.src || data.url,
+                    url: data.url || data.src
+                });
+                brief += `<$${type},${Object.entries(data).map(([key, value]) => `${key}=${value}`).join(',')}>`;
+            }
+        }
+        delete payload.attachments;
+        delete payload.mentions;
+        return [result, brief];
+    }
+    Message.parse = parse;
+    async function format(message, source = {}) {
+        const getType = (type) => {
+            return ['image', 'video', 'audio'].indexOf(type) + 1;
+        };
+        let brief = '';
+        const messages = {
+            msg_type: 0,
+            content: '',
+            msg_id: source?.message_id,
+            msg_seq: (0, crypto_1.randomInt)(1, 1000000),
+            timestamp: Number((Date.now() / 1000).toFixed(0))
+        };
+        const files = {
+            msg_id: source?.message_id,
+            msg_seq: (0, crypto_1.randomInt)(1, 1000000),
+            timestamp: Number((Date.now() / 1000).toFixed(0))
+        };
+        let hasMessages = false, hasFiles = false, buttons = [];
+        if (!Array.isArray(message))
+            message = [message];
+        for (let elem of message) {
+            if (typeof elem === 'string') {
+                elem = { type: 'text', text: elem };
+            }
+            switch (elem.type) {
+                case 'reply':
+                    messages.msg_id = elem.message_id;
+                    files.msg_id = elem.message_id;
+                    brief += `<$reply,message_id=${elem.message_id}>`;
+                    break;
+                case "at":
+                    if (messages.content) {
+                        messages.content += `<@${elem.id || 'everyone'}>`;
+                    }
+                    else {
+                        messages.content = `<@${elem.id || 'everyone'}>`;
+                    }
+                    brief += `<$at,user=${elem.id || 'everyone'}>`;
+                    break;
+                case 'link':
+                    if (messages.content) {
+                        messages.content += `<#${elem.channel_id}>`;
+                    }
+                    else {
+                        messages.content = `<#${elem.channel_id}>`;
+                    }
+                    brief += `<$link,channel=${elem.channel_id}>`;
+                    break;
+                case 'text':
+                    if (messages.content) {
+                        messages.content += elem.text;
+                    }
+                    else {
+                        messages.content = elem.text;
+                    }
+                    hasMessages = true;
+                    brief += elem.text;
+                    break;
+                case 'face':
+                    if (messages.content) {
+                        messages.content += `<emoji:${elem.id}>`;
+                    }
+                    else {
+                        messages.content = `<emoji:${elem.id}>`;
+                    }
+                    brief += `<$face,id=${elem.id}>`;
+                    hasMessages = true;
+                    break;
+                case 'image':
+                case 'audio':
+                case 'video':
+                    files.file_type = getType(elem.type);
+                    files.content = 'file';
+                    files.url = elem.file;
+                    files.event_id = source.event_id;
+                    files.msg_id = source?.message_id;
+                    files.srv_send_msg = true;
+                    hasFiles = true;
+                    brief += `<${elem.type},file=${elem.file}>`;
+                    break;
+                case 'markdown':
+                    messages.markdown = {
+                        content: elem.content
+                    };
+                    messages.msg_type = 2;
+                    hasMessages = true;
+                    brief += `<#markdown,content=${elem.content}>`;
+                    break;
+                case 'button':
+                    buttons.push(elem.data);
+                    brief += `<$button,data=${JSON.stringify(elem.data)}>`;
+                    break;
+            }
+        }
+        if (buttons.length) {
+            const rows = [];
+            for (let i = 0; i < buttons.length; i += 4) {
+                rows.push(buttons.slice(i, i + 4));
+            }
+            messages.keyboard = {
+                content: {
+                    rows: rows.map(row => {
+                        return {
+                            buttons: row
+                        };
+                    })
+                }
+            };
+        }
+        return {
+            messages: messages,
+            hasFiles,
+            hasMessages,
+            brief,
+            files
+        };
+    }
+    Message.format = format;
+})(Message || (exports.Message = Message = {}));

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

@@ -0,0 +1,122 @@
+/// <reference types="node" />
+import { AxiosInstance } from "axios";
+import { WebSocket } from "ws";
+import * as log4js from 'log4js';
+import { EventEmitter } from "events";
+import { SessionManager } from "./sessionManager";
+import { Quotable, Sendable } from "./elements";
+import { ApiBaseInfo, Dict, LogLevel, UpdatePermissionParams } from "./types";
+import { DirectMessageEvent, GroupMessageEvent, GuildMessageEvent, PrivateMessageEvent } from "./message";
+import { EventMap } from "./event";
+import { Channel } from "../../adapters/qq/entries/channel";
+import { Guild } from "../../adapters/qq/entries/guild";
+export declare class QQBot extends EventEmitter {
+    config: QQBot.Config;
+    request: AxiosInstance;
+    self_id: string;
+    nickname: string;
+    status: number;
+    logger: log4js.Logger;
+    ws: WebSocket;
+    sessionManager: SessionManager;
+    constructor(config: QQBot.Config);
+    removeAt(payload: Dict): void;
+    processPayload(event_id: string, event: string, payload: Dict): GroupMessageEvent | PrivateMessageEvent | GuildMessageEvent | DirectMessageEvent | Dict;
+    getSelfInfo(): Promise<any>;
+    getChannelPermissionOfRole(channel_id: string, role_id: string): Promise<any>;
+    setChannelAnnounce(guild_id: string, channel_id: string, message_id: string): Promise<any>;
+    updateChannelPermissionOfRole(channel_id: string, role_id: string, permission: UpdatePermissionParams): Promise<boolean>;
+    getChannelMemberPermission(channel_id: string, member_id: string): Promise<any>;
+    updateChannelMemberPermission(channel_id: string, member_id: string, permission: UpdatePermissionParams): Promise<boolean>;
+    getChannelPins(channel_id: string): Promise<string[]>;
+    pinChannelMessage(channel_id: string, message_id: string): Promise<any>;
+    unPinChannelMessage(channel_id: string, message_id: string): Promise<any>;
+    createChannel(guild_id: string, channelInfo: Omit<Channel.Info, 'id'>): Promise<Channel.Info>;
+    updateChannel({ channel_id, ...updateInfo }: {
+        channel_id: string;
+    } & Partial<Pick<Channel.Info, 'name' | 'position' | 'parent_id' | 'private_type' | 'speak_permission'>>): Promise<Channel.Info>;
+    deleteChannel(channel_id: string): Promise<boolean>;
+    getGuildRoles(guild_id: string): Promise<any>;
+    creatGuildRole(guild_id: string, role: Pick<Guild.Role, 'name' | 'color' | 'hoist'>): Promise<Guild.Role>;
+    updateGuildRole(guild_id: string, { id, ...role }: Pick<Guild.Role, 'id' | 'name' | 'color' | 'hoist'>): Promise<any>;
+    deleteGuildRole(role_id: string): Promise<boolean>;
+    getGuildAccessApis(guild_id: string): Promise<any>;
+    applyGuildAccess(guild_id: string, channel_id: string, apiInfo: ApiBaseInfo, desc?: string): Promise<any>;
+    unMuteGuild(guild_id: string): Promise<boolean>;
+    muteGuild(guild_id: string, seconds: number, end_time?: number): Promise<boolean>;
+    unMuteGuildMembers(guild_id: string, member_ids: string[]): Promise<boolean>;
+    muteGuildMembers(guild_id: string, member_ids: string[], seconds: number, end_time?: number): Promise<boolean>;
+    addGuildMemberRoles(guild_id: string, channel_id: string, member_id: string, role_id: string): Promise<boolean>;
+    removeGuildMemberRoles(guild_id: string, channel_id: string, member_id: string, role_id: string): Promise<boolean>;
+    kickGuildMember(guild_id: string, member_id: string, clean?: -1 | 0 | 3 | 7 | 15 | 30, blacklist?: boolean): Promise<boolean>;
+    unMuteGuildMember(guild_id: string, member_id: string): Promise<boolean>;
+    muteGuildMember(guild_id: string, member_id: string, seconds: number, end_time?: number): Promise<boolean>;
+    getGuildList(): Promise<any>;
+    getGuildMemberList(guild_id: string): Promise<any>;
+    getGuildMemberInfo(guild_id: string, member_id: string): Promise<any>;
+    getChannelInfo(channel_id: string): Promise<any>;
+    getGroupMemberList(group_id: string): Promise<void>;
+    getGroupMemberInfo(group_id: string, member_id: string): Promise<void>;
+    getFriendList(): Promise<void>;
+    getFriendInfo(friend_id: string): Promise<void>;
+    getChannelList(guild_id: string): Promise<any>;
+    sendPrivateMessage(user_id: string, message: Sendable, source?: Quotable): Promise<{
+        message_id: string;
+        timestamp: number;
+    }>;
+    createDirectSession(guild_id: string, user_id: string): Promise<any>;
+    sendDirectMessage(guild_id: string, message: Sendable, source?: Quotable): Promise<{
+        message_id: string;
+        timestamp: number;
+    }>;
+    sendGuildMessage(channel_id: string, message: Sendable, source?: Quotable): Promise<{
+        message_id: string;
+        timestamp: number;
+    }>;
+    sendGroupMessage(group_id: string, message: Sendable, source?: Quotable): Promise<{
+        message_id: string;
+        timestamp: number;
+    }>;
+    dispatchEvent(event: string, wsRes: any): void;
+    em(event: string, payload: Dict): void;
+}
+export interface QQBot {
+    on<T extends keyof EventMap>(event: T, callback: EventMap[T]): this;
+    on<S extends string | symbol>(event: S & Exclude<string | symbol, keyof EventMap>, callback: (...args: any[]) => void): this;
+    once<T extends keyof EventMap>(event: T, callback: EventMap[T]): this;
+    once<S extends string | symbol>(event: S & Exclude<string | symbol, keyof EventMap>, callback: (...args: any[]) => void): this;
+    off<T extends keyof EventMap>(event: T, callback?: EventMap[T]): this;
+    off<S extends string | symbol>(event: S & Exclude<string | symbol, keyof EventMap>, callback?: (...args: any[]) => void): this;
+    emit<T extends keyof EventMap>(event: T, ...args: Parameters<EventMap[T]>): boolean;
+    emit<S extends string | symbol>(event: S & Exclude<string | symbol, keyof EventMap>, ...args: any[]): boolean;
+    addListener<T extends keyof EventMap>(event: T, callback: EventMap[T]): this;
+    addListener<S extends string | symbol>(event: S & Exclude<string | symbol, keyof EventMap>, callback: (...args: any[]) => void): this;
+    addListenerOnce<T extends keyof EventMap>(event: T, callback: EventMap[T]): this;
+    addListenerOnce<S extends string | symbol>(event: S & Exclude<string | symbol, keyof EventMap>, callback: (...args: any[]) => void): this;
+    removeListener<T extends keyof EventMap>(event: T, callback?: EventMap[T]): this;
+    removeListener<S extends string | symbol>(event: S & Exclude<string | symbol, keyof EventMap>, callback?: (...args: any[]) => void): this;
+    removeAllListeners<T extends keyof EventMap>(event: T): this;
+    removeAllListeners<S extends string | symbol>(event: S & Exclude<string | symbol, keyof EventMap>): this;
+}
+export declare namespace QQBot {
+    interface Token {
+        access_token: string;
+        expires_in: number;
+        cache: string;
+    }
+    interface Config {
+        appid: string;
+        secret: string;
+        token?: string;
+        sandbox?: boolean;
+        maxRetry?: number;
+        /**
+         * 是否移除第一个@
+         */
+        removeAt?: boolean;
+        delay?: Dict<number>;
+        intents?: string[];
+        logLevel?: LogLevel;
+    }
+    function getFullTargetId(message: GuildMessageEvent | GroupMessageEvent | PrivateMessageEvent): string;
+}