onebots 0.4.23 → 0.4.26

package/lib/adapters/qq/sessionManager.js

@@ -0,0 +1,257 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = exports.MAX_RETRY = void 0;
+const axios_1 = __importDefault(require("axios"));
+const ws_1 = require("ws");
+const utils_1 = require("./utils");
+const events_1 = require("events");
+const constans_1 = require("./constans");
+exports.MAX_RETRY = 10;
+class SessionManager extends events_1.EventEmitter {
+    get token() {
+        return this.bot.config.token;
+    }
+    constructor(bot) {
+        super();
+        this.bot = bot;
+        this.retry = 0;
+        this.sessionRecord = {
+            sessionID: "",
+            seq: 0
+        };
+        this.heartbeatParam = {
+            op: constans_1.OpCode.HEARTBEAT,
+            d: null // 心跳唯一值
+        };
+        this.on(constans_1.SessionEvents.EVENT_WS, (data) => {
+            switch (data.eventType) {
+                case constans_1.SessionEvents.RECONNECT:
+                    this.bot.logger.mark("[CLIENT] 等待断线重连中...");
+                    break;
+                case constans_1.SessionEvents.DISCONNECT:
+                    if (this.retry < (this.bot.config.maxRetry || exports.MAX_RETRY)) {
+                        this.bot.logger.mark("[CLIENT] 重新连接中，尝试次数：", this.retry + 1);
+                        if (constans_1.WebsocketCloseReason.find((v) => v.code === data.code)?.resume) {
+                            this.sessionRecord = data.eventMsg;
+                        }
+                        this.isReconnect = true;
+                        this.start();
+                        this.retry += 1;
+                    }
+                    else {
+                        this.bot.logger.mark("[CLIENT] 超过重试次数，连接终止");
+                        this.emit(constans_1.SessionEvents.DEAD, {
+                            eventType: constans_1.SessionEvents.ERROR,
+                            msg: "连接已死亡，请检查网络或重启"
+                        });
+                    }
+                    break;
+                case constans_1.SessionEvents.READY:
+                    this.bot.logger.mark("[CLIENT] 连接成功");
+                    this.retry = 0;
+                    break;
+                default:
+            }
+        });
+    }
+    async getAccessToken() {
+        let { secret, appid } = this.bot.config;
+        const getToken = () => {
+            return new Promise((resolve, reject) => {
+                axios_1.default.post("https://bots.qq.com/app/getAppAccessToken", {
+                    appId: appid,
+                    clientSecret: secret
+                }).then(res => {
+                    if (res.status === 200 && res.data && typeof res.data === "object") {
+                        resolve(res.data);
+                    }
+                    else {
+                        reject(res);
+                    }
+                });
+            });
+        };
+        const getNext = async (next_time) => {
+            return new Promise(resolve => {
+                setTimeout(async () => {
+                    const token = await getToken();
+                    this.bot.logger.debug("getAccessToken", token);
+                    this.access_token = token.access_token;
+                    getNext(token.expires_in - 1).catch(() => getNext(0));
+                    resolve(token);
+                }, next_time * 1000);
+            });
+        };
+        return getNext(0);
+    }
+    async getWsUrl() {
+        return new Promise((resolve) => {
+            this.bot.request.get("/gateway/bot", {
+                headers: {
+                    Accept: "*/*",
+                    "Accept-Encoding": "utf-8",
+                    "Accept-Language": "zh-CN,zh;q=0.8",
+                    Connection: "keep-alive",
+                    "User-Agent": "v1",
+                    Authorization: ""
+                }
+            }).then(res => {
+                if (!res.data)
+                    throw new Error("获取ws连接信息异常");
+                this.wsUrl = res.data.url;
+                resolve();
+            });
+        });
+    }
+    getValidIntends() {
+        return (this.bot.config.intents || []).reduce((result, item) => {
+            const value = constans_1.Intends[item];
+            if (value === undefined) {
+                this.bot.logger.warn(`Invalid intends(${item}),skip...`);
+                return result;
+            }
+            return constans_1.Intends[item] | result;
+        }, 0);
+    }
+    async start() {
+        await this.getAccessToken();
+        await this.getWsUrl();
+        this.connect();
+        this.startListen();
+    }
+    connect() {
+        this.bot.ws = new ws_1.WebSocket(this.wsUrl, {
+            headers: {
+                "Authorization": "QQBot " + this.access_token,
+                "X-Union-Appid": this.bot.config.appid
+            }
+        });
+    }
+    reconnectWs() {
+        const reconnectParam = {
+            op: constans_1.OpCode.RESUME,
+            d: {
+                // token: `Bot ${this.bot.appId}${this.token}`,
+                token: `QQBot ${this.access_token}`,
+                session_id: this.sessionRecord.sessionID,
+                seq: this.sessionRecord.seq
+            }
+        };
+        this.sendWs(reconnectParam);
+    }
+    // 发送websocket
+    sendWs(msg) {
+        try {
+            // 先将消息转为字符串
+            this.bot.ws.send(typeof msg === "string" ? msg : JSON.stringify(msg));
+        }
+        catch (e) {
+            this.bot.logger.error(e);
+        }
+    }
+    authWs() {
+        // 鉴权参数
+        const authOp = {
+            op: constans_1.OpCode.IDENTIFY,
+            d: {
+                // token: `Bot ${this.bot.appId}${this.token}`,
+                token: `QQBot ${this.access_token}`,
+                intents: this.getValidIntends(),
+                shard: [0, 1] // 分片信息,给一个默认值
+            }
+        };
+        // 发送鉴权请求
+        this.sendWs(authOp);
+    }
+    startListen() {
+        this.bot.ws.on("open", () => {
+            this.bot.logger.info("[CLIENT] 连接成功");
+        });
+        this.bot.ws.on("close", (code) => {
+            this.bot.logger.error(`[CLIENT] 连接关闭：${code}`);
+            this.emit(constans_1.SessionEvents.EVENT_WS, {
+                eventType: constans_1.SessionEvents.DISCONNECT,
+                code,
+                eventMsg: this.sessionRecord
+            });
+            if (code) {
+                constans_1.WebsocketCloseReason.forEach((e) => {
+                    if (e.code === code) {
+                        this.emit(constans_1.SessionEvents.ERROR, e.reason);
+                    }
+                });
+            }
+        });
+        this.bot.ws.on("error", (e) => {
+            this.bot.logger.error("[CLIENT] 连接错误");
+            this.emit(constans_1.SessionEvents.CLOSED, { eventType: constans_1.SessionEvents.CLOSED });
+        });
+        this.bot.ws.on("message", (data) => {
+            this.bot.logger.debug(`[CLIENT] 收到消息: ${data}`);
+            // 先将消息解析
+            const wsRes = (0, utils_1.toObject)(data);
+            // 先判断websocket连接是否成功
+            if (wsRes?.op === constans_1.OpCode.HELLO && wsRes?.d?.heartbeat_interval) {
+                // websocket连接成功，拿到心跳周期
+                this.heartbeatInterval = wsRes?.d?.heartbeat_interval;
+                // 非断线重连时，需要鉴权
+                this.isReconnect ? this.reconnectWs() : this.authWs();
+                return;
+            }
+            // 鉴权通过
+            if (wsRes.t === constans_1.SessionEvents.READY) {
+                this.bot.logger.info(`[CLIENT] 鉴权通过`);
+                const { d, s } = wsRes;
+                const { session_id, user = {} } = d;
+                this.bot.self_id = user.id;
+                this.bot.nickname = user.username;
+                this.bot.status = user.status || 0;
+                // 获取当前会话参数
+                if (session_id && s) {
+                    this.sessionRecord.sessionID = session_id;
+                    this.sessionRecord.seq = s;
+                    this.heartbeatParam.d = s;
+                }
+                this.bot.logger.info(`connect to ${user.username}(${user.id})`);
+                this.isReconnect = false;
+                this.emit(constans_1.SessionEvents.READY, { eventType: constans_1.SessionEvents.READY, msg: d || "" });
+                // 第一次发送心跳
+                this.bot.logger.debug(`[CLIENT] 发送第一次心跳`, this.heartbeatParam);
+                this.sendWs(this.heartbeatParam);
+                return;
+            }
+            // 心跳测试
+            if (wsRes.op === constans_1.OpCode.HEARTBEAT_ACK || wsRes.t === constans_1.SessionEvents.RESUMED) {
+                if (!this.alive) {
+                    this.alive = true;
+                    this.emit(constans_1.SessionEvents.EVENT_WS, { eventType: constans_1.SessionEvents.READY });
+                }
+                this.bot.logger.debug("[CLIENT] 心跳校验", this.heartbeatParam);
+                setTimeout(() => {
+                    this.sendWs(this.heartbeatParam);
+                }, this.heartbeatInterval);
+            }
+            // 收到服务端重连的通知
+            if (wsRes.op === constans_1.OpCode.RECONNECT) {
+                // 通知会话，当前已断线
+                this.emit(constans_1.SessionEvents.EVENT_WS, { eventType: constans_1.SessionEvents.RECONNECT });
+            }
+            // 服务端主动推送的消息
+            if (wsRes.op === constans_1.OpCode.DISPATCH) {
+                // 更新心跳唯一值
+                const { s } = wsRes;
+                if (s)
+                    this.sessionRecord.seq = this.heartbeatParam.d = s;
+                // OpenAPI事件分发
+                this.bot.dispatchEvent(wsRes.t, wsRes);
+            }
+        });
+        this.on(constans_1.SessionEvents.ERROR, (e) => {
+            this.bot.logger.error(`[CLIENT] 发生错误：${e}`);
+        });
+    }
+}
+exports.SessionManager = SessionManager;

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

@@ -0,0 +1,45 @@
+import { ChannelSubType, ChannelType, PrivateType, SpeakPermission } from "./constans";
+export type Dict<T = any> = Record<string, T>;
+export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal" | "mark" | "off";
+export interface wsResData {
+    op: number;
+    d?: {
+        heartbeat_interval?: number;
+        session_id?: string;
+        user?: {
+            id?: string;
+            username?: string;
+            bot?: boolean;
+            status?: number;
+        };
+    };
+    s: number;
+    t: string;
+    id?: string;
+}
+export interface ChannelInfo {
+    id: string;
+    guild_id: string;
+    name: string;
+    type: ChannelType;
+    sub_type: ChannelSubType;
+    position: number;
+    parent_id?: string;
+    owner_id: string;
+    private_type: PrivateType;
+    speak_permission: SpeakPermission;
+    application_id?: string;
+    permissions?: string;
+}
+export type UpdatePermissionParams = {
+    add?: string;
+    remove?: string;
+};
+export type ApiBaseInfo = {
+    path: string;
+    method: "GET" | "POST" | "DELETE" | "PATCH" | "PUT";
+};
+export type RecommendInfo = {
+    channel_id: string;
+    introduce: string;
+};

package/lib/adapters/qq/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,12 @@
+export declare const toObject: <T = any>(data: any) => T;
+export declare function isEmpty<T>(data: T): boolean;
+export declare function remove<T>(list: T[], item: T): void;
+export declare function deepClone<T extends object>(obj: T): any;
+/**
+ * 寻找数组中最后一个符合条件的元素下标
+ * @param list 数组
+ * @param predicate 条件
+ * @returns {number} 元素下标，未找到返回-1
+ */
+export declare function findLastIndex<T>(list: T[], predicate: (item: T, index: number) => boolean): number;
+export declare function trimQuote(str: string): string;

package/lib/adapters/qq/utils.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trimQuote = exports.findLastIndex = exports.deepClone = exports.remove = exports.isEmpty = exports.toObject = void 0;
+const toObject = (data) => {
+    if (Buffer.isBuffer(data))
+        return JSON.parse(data.toString());
+    if (typeof data === 'object')
+        return data;
+    if (typeof data === 'string')
+        return JSON.parse(data);
+    // return String(data);
+};
+exports.toObject = toObject;
+function isEmpty(data) {
+    if (!data)
+        return true;
+    if (typeof data !== "object")
+        return false;
+    return Reflect.ownKeys(data).length === 0;
+}
+exports.isEmpty = isEmpty;
+function remove(list, item) {
+    const index = list.indexOf(item);
+    if (index !== -1)
+        list.splice(index, 1);
+}
+exports.remove = remove;
+function deepClone(obj) {
+    if (typeof obj !== "object")
+        return obj;
+    if (Array.isArray(obj))
+        return obj.map(deepClone);
+    const Constructor = obj.constructor;
+    let newObj = Constructor();
+    for (let key in obj) {
+        newObj[key] = deepClone(obj[key]);
+    }
+    return newObj;
+}
+exports.deepClone = deepClone;
+/**
+ * 寻找数组中最后一个符合条件的元素下标
+ * @param list 数组
+ * @param predicate 条件
+ * @returns {number} 元素下标，未找到返回-1
+ */
+function findLastIndex(list, predicate) {
+    for (let i = list.length - 1; i >= 0; i--) {
+        if (predicate(list[i], i))
+            return i;
+    }
+    return -1;
+}
+exports.findLastIndex = findLastIndex;
+function trimQuote(str) {
+    const quotes = [
+        [
+            '"',
+            '"',
+        ],
+        [
+            "'",
+            "'",
+        ],
+        [
+            '`',
+            '`',
+        ],
+        [
+            '“',
+            '”',
+        ],
+        [
+            '‘',
+            '’',
+        ]
+    ];
+    for (let i = 0; i < quotes.length; i++) {
+        const [start, end] = quotes[i];
+        if (str.startsWith(start) && str.endsWith(end)) {
+            return str.slice(1, -1);
+        }
+    }
+    return str;
+}
+exports.trimQuote = trimQuote;

package/lib/bin.js

@@ -5,6 +5,21 @@ const app_1 = require("./server/app");
 const execArgv = process.argv.splice(2);
 const obj = {};
 for (let i = 0; i < execArgv.length; i += 2) {
-    obj[execArgv[i]] = execArgv[i + 1];
+    const key = execArgv[i];
+    const value = execArgv[i + 1];
+    if (!obj[key])
+        obj[key] = value;
+    else {
+        if (Array.isArray(obj[key]))
+            obj[key].push(value);
+        else
+            obj[key] = [obj[key], value];
+    }
 }
-(0, app_1.createApp)(obj["-c"]).start();
+if (obj['-r']) {
+    const adapters = [].concat(obj['-r']);
+    for (const adapter of adapters) {
+        app_1.App.registerAdapter(adapter);
+    }
+}
+(0, app_1.createOnebots)(obj['-c']).start();

package/lib/config.sample.yaml

@@ -1,6 +1,5 @@
 port: 6727 # 监听端口
 log_level: info # 日志等级
-platform: 5 # 机器人客户端协议（1:Android 2:APad 3:Watch 4:IMac 5:IPad）
 timeout: 30 #登录超时时间(秒)
 general: # 通用配置，在单个配置省略时的默认值
   V11: # oneBotV11的通用配置
@@ -29,10 +28,29 @@ general: # 通用配置，在单个配置省略时的默认值
   protocol:
     platform: 2
 # 每个账号的单独配置(用于覆盖通用配置)
-123456789:
-  version: V11 # 使用的oneBot版本
-  password: '' # 账号密码，未配置则扫码登陆
-  group_whitelist: [] # 群消息派发白名单，只有数组中的群号才派发，为空则全部派发
+icqq.123456789: # `${适配器名称}:${账号}`
+  versions:
+    - version: V12
+  # 。。。其他配置项参见上方对应oneBot版本的通用配置
   protocol: # 将会覆盖通用配置中的protocol
     platform: 1
   # 。。。其他配置项参见上方对应oneBot版本的通用配置
+qq.a: # `${适配器名称}:${账号}`
+  versions:
+    - version: V11
+  # 。。。其他配置项参见上方对应oneBot版本的通用配置
+  protocol: # 将会覆盖通用配置中的protocol
+    token: '' # qq机器人token
+    secret: '' # qq机器人secret
+    sandbox: false # 是否沙箱环境
+    intents: # 需要监听的intents
+      - 'GROUP_AT_MESSAGE_CREATE' # 群聊@事件 没有群聊权限请注释
+      - 'C2C_MESSAGE_CREATE' # 私聊事件 没有私聊权限请注释
+      - 'DIRECT_MESSAGE' # 频道私信事件
+      #     - 'GUILD_MESSAGES' # 私域机器人频道消息事件，公域机器人请注释
+      - 'GUILDS' # 频道变更事件
+      - 'GUILD_MEMBERS' # 频道成员变更事件
+      - 'GUILD_MESSAGE_REACTIONS' # 频道消息表态事件
+      - 'INTERACTION' # 互动事件
+      - 'PUBLIC_GUILD_MESSAGES' # 公域机器人频道消息事件，私域机器人请注释
+  # 。。。其他配置项参见上方对应oneBot版本的通用配置

package/lib/onebot.d.ts

@@ -1,50 +1,58 @@
 /// <reference types="node" />
-import "icqq-cq-enable";
-import { EventEmitter } from "events";
-import { App } from "./server/app";
-import { Client } from "icqq";
-import { Config as IcqqConfig } from "icqq";
+import { EventEmitter } from 'events';
 import { V11 } from "./service/V11";
 import { V12 } from "./service/V12";
-import { MayBeArray } from "./types";
+import { Adapter } from "./adapter";
 import { Service } from "./service";
+import { Logger } from "log4js";
 export declare class NotFoundError extends Error {
     message: string;
 }
-export declare class OneBot<V extends OneBot.Version> extends EventEmitter {
-    app: App;
-    readonly uin: number;
-    config: OneBotConfig[];
+export declare class OneBot<V extends OneBot.Version = OneBot.Version> extends EventEmitter {
+    #private;
+    adapter: Adapter;
+    readonly uin: string;
+    config: OneBot.Config[];
     status: OneBotStatus;
     protected password: string;
-    client: Client;
+    internal?: any;
     instances: (V11 | V12)[];
-    constructor(app: App, uin: number, config: MayBeArray<OneBotConfig>);
-    start(): Promise<[boolean, any]>;
-    startListen(): void;
+    get app(): import(".").App;
+    get platform(): string;
+    get logger(): Logger;
+    constructor(adapter: Adapter, uin: string, version_configs: OneBot.Config[]);
+    start(): Promise<void>;
     stop(force?: boolean): Promise<void>;
-    system_online(event: any, data: any): void;
+    getGroupList<V extends OneBot.Version>(version: V): Promise<OneBot.GroupInfo<V>[]>;
+    getFriendList<V extends OneBot.Version>(version: V): Promise<OneBot.UserInfo<V>[]>;
     dispatch(event: any, data: any): Promise<void>;
 }
 export declare enum OneBotStatus {
     Good = 0,
-    Bad = 1
+    Bad = 1,
+    Online = "online"
 }
-export type OneBotConfig = OneBot.Config<OneBot.Version>;
 export declare namespace OneBot {
     type Filters = {};
-    type Version = "V11" | "V12";
-    type Config<V extends Version = "V11"> = {
+    type Version = 'V11' | 'V12';
+    type Config<V extends Version = Version> = {
         version?: V;
-        password?: string;
-        group_whitelist?: number[];
         filters?: Service.Filters;
-        protocol?: IcqqConfig;
-    } & (V extends "V11" ? V11.Config : V12.Config);
+    } & (V extends 'V11' ? V11.Config : V12.Config);
+    const UnsupportedMethodError: Error;
+    const UnsupportedVersionError: Error;
+    type Payload<V extends Version = Version> = V extends 'V11' ? V11.Payload : V12.Payload;
+    type Segment<V extends Version = Version> = V extends 'V11' ? V11.Segment : V12.Segment;
+    type SelfInfo<V extends Version = Version> = V extends 'V11' ? V11.SelfInfo : V12.SelfInfo;
+    type GroupInfo<V extends Version> = V extends 'V11' ? V11.GroupInfo : V12.GroupInfo;
+    type UserInfo<V extends Version> = V extends 'V11' ? V11.UserInfo : V12.UserInfo;
+    type Message<V extends Version> = V extends 'V11' ? V11.Message : V12.Message;
+    type MessageElement<V extends Version> = V extends 'V11' ? V11.MessageElement : V12.MessageElement;
+    type GroupMemberInfo<V extends Version> = V extends 'V11' ? V11.GroupMemberInfo : V12.GroupMemberInfo;
+    type MessageRet<V extends Version> = V extends 'V11' ? V11.MessageRet : V12.MessageRet;
     interface Base {
         start(path?: string): any;
         stop(): any;
-        system_online(...args: any[]): any;
         dispatch(...args: any[]): any;
         apply(...args: any[]): any;
     }