onebots 0.0.1

package/lib/service/V11/index.js

@@ -0,0 +1,481 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V11 = void 0;
+const action_1 = require("./action");
+const ws_1 = require("ws");
+const url_1 = require("url");
+const utils_1 = require("../../utils");
+const icqq_cq_enable_1 = require("icqq-cq-enable");
+const onebot_1 = require("../../onebot");
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const events_1 = require("events");
+class V11 extends events_1.EventEmitter {
+    constructor(oneBot, client, config) {
+        super();
+        this.oneBot = oneBot;
+        this.client = client;
+        this.config = config;
+        this.version = 'V11';
+        this.timestamp = Date.now();
+        this._queue = [];
+        this.queue_running = false;
+        this.wsr = new Set();
+        this.action = new action_1.Action();
+        this.logger = this.oneBot.app.getLogger(this.client.uin, this.version);
+    }
+    start(path) {
+        this.path = `/${this.client.uin}`;
+        if (path)
+            this.path += path;
+        if (this.config.use_http)
+            this.startHttp();
+        if (this.config.use_ws)
+            this.startWs();
+        this.config.http_reverse.forEach(config => {
+            if (typeof config === 'string') {
+                config = {
+                    url: config,
+                    access_token: this.config.access_token,
+                    secret: this.config.secret
+                };
+            }
+            else {
+                config = {
+                    access_token: this.config.access_token,
+                    secret: this.config.secret,
+                    ...config
+                };
+            }
+            this.startHttpReverse(config);
+        });
+        this.config.ws_reverse.forEach(config => {
+            this.startWsReverse(config);
+        });
+        if (this.config.heartbeat) {
+            this.heartbeat = setInterval(() => {
+                this.dispatch({
+                    self_id: this.client.uin,
+                    time: Math.floor(Date.now() / 1000),
+                    post_type: "meta_event",
+                    meta_event_type: "heartbeat",
+                    interval: this.config.heartbeat * 1000,
+                });
+            }, this.config.heartbeat * 1000);
+        }
+    }
+    startHttp() {
+        this.oneBot.app.router.all(new RegExp(`^${this.path}/(.*)$`), this._httpRequestHandler.bind(this));
+        this.logger.mark(`开启http服务器成功，监听:http://127.0.0.1:${this.oneBot.app.config.port}${this.path}`);
+    }
+    startHttpReverse(config) {
+        this.on('dispatch', (unserialized) => {
+            const serialized = JSON.stringify(unserialized);
+            const options = {
+                method: "POST",
+                timeout: this.config.post_timeout * 1000,
+                headers: {
+                    "Content-Type": "application/json",
+                    "Content-Length": Buffer.byteLength(serialized),
+                    "X-Self-ID": String(this.client.uin),
+                    "User-Agent": "OneBot",
+                },
+            };
+            if (this.config.secret) {
+                //@ts-ignore
+                options.headers["X-Signature"] = "sha1=" + crypto.createHmac("sha1", String(this.config.secret)).update(serialized).digest("hex");
+            }
+            const protocol = config.url.startsWith("https") ? https_1.default : http_1.default;
+            try {
+                protocol.request(config.url, options, (res) => {
+                    if (res.statusCode !== 200)
+                        return this.logger.warn(`POST(${config.url})上报事件收到非200响应：` + res.statusCode);
+                    let data = "";
+                    res.setEncoding("utf-8");
+                    res.on("data", (chunk) => data += chunk);
+                    res.on("end", () => {
+                        this.logger.debug(`收到HTTP响应 ${res.statusCode} ：` + data);
+                        if (!data)
+                            return;
+                        try {
+                            this._quickOperate(unserialized, JSON.parse(data));
+                        }
+                        catch (e) {
+                            this.logger.error(`快速操作遇到错误：` + e.message);
+                        }
+                    });
+                }).on("error", (err) => {
+                    this.logger.error(`POST(${config.url})上报事件失败：` + err.message);
+                }).end(serialized, () => {
+                    this.logger.debug(`POST(${config.url})上报事件成功: ` + serialized);
+                });
+            }
+            catch (e) {
+                this.logger.error(`POST(${config.url})上报失败：` + e.message);
+            }
+        });
+    }
+    startWs() {
+        this.wss = this.oneBot.app.router.ws(this.path, this.oneBot.app.httpServer);
+        this.logger.mark(`开启ws服务器成功，监听:ws://127.0.0.1:${this.oneBot.app.config.port}${this.path}`);
+        this.wss.on("error", (err) => {
+            this.logger.error(err.message);
+        });
+        this.wss.on("connection", (ws, req) => {
+            this.logger.info(`ws客户端(${req.headers.origin})已连接`);
+            ws.on("error", (err) => {
+                this.logger.error(`ws客户端(${req.headers.origin})报错：${err.message}`);
+            });
+            ws.on("close", (code, reason) => {
+                this.logger.warn(`ws客户端(${req.headers.origin})连接关闭，关闭码${code}，关闭理由：` + reason);
+            });
+            if (this.config.access_token) {
+                const url = new url_1.URL(req.url, "http://127.0.0.1");
+                const token = url.searchParams.get('access_token');
+                if (token)
+                    req.headers["authorization"] = `Bearer ${token}`;
+                if (!req.headers["authorization"] || req.headers["authorization"] !== `Bearer ${this.config.access_token}`)
+                    return ws.close(1002, "wrong access token");
+            }
+            this._webSocketHandler(ws);
+        });
+        this.on('dispatch', (serialized) => {
+            for (const ws of this.wss.clients) {
+                ws.send(serialized, (err) => {
+                    if (err)
+                        this.logger.error(`正向WS(${ws.url})上报事件失败: ` + err.message);
+                    else
+                        this.logger.debug(`正向WS(${ws.url})上报事件成功: ` + serialized);
+                });
+            }
+        });
+    }
+    startWsReverse(url) {
+        const ws = this._createWsr(url);
+        this.on('dispatch', (unserialized) => {
+            if (this.wsr.has(ws)) {
+                ws.send(JSON.stringify(unserialized));
+            }
+        });
+    }
+    stop() {
+        this.client.logout();
+    }
+    dispatch(data) {
+        if (!data.post_type)
+            data.post_type = 'system';
+        if (data.post_type === 'system') {
+        }
+        if (data.message && data.post_type === 'message') {
+            data.message = this.config.post_message_format === 'array' ? (0, icqq_cq_enable_1.toSegment)(data.message) : (0, icqq_cq_enable_1.toCqcode)(data);
+        }
+        this.emit('dispatch', JSON.stringify(data));
+    }
+    async _httpRequestHandler(ctx) {
+        if (ctx.method === 'OPTIONS') {
+            return ctx.writeHead(200, {
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, authorization'
+            }).end();
+        }
+        const url = new url_1.URL(ctx.url, `http://127.0.0.1`);
+        if (this.config.access_token) {
+            if (ctx.headers["authorization"]) {
+                if (ctx.headers["authorization"] !== `Bearer ${this.config.access_token}`)
+                    return ctx.res.writeHead(403).end();
+            }
+            else {
+                const access_token = url.searchParams.get("access_token");
+                if (!access_token)
+                    return ctx.res.writeHead(401).end();
+                else if (access_token !== this.config.access_token)
+                    return ctx.res.writeHead(403).end();
+            }
+        }
+        ctx.res.setHeader("Content-Type", "application/json; charset=utf-8");
+        if (this.config.enable_cors)
+            ctx.res.setHeader("Access-Control-Allow-Origin", "*");
+        const action = url.pathname.replace(`${this.path}`, '').slice(1);
+        if (ctx.method === "GET") {
+            try {
+                const ret = await this.apply({ action, params: ctx.query });
+                ctx.res.writeHead(200).end(ret);
+            }
+            catch (e) {
+                ctx.res.writeHead(500).end(e.message);
+            }
+        }
+        else if (ctx.method === "POST") {
+            try {
+                const params = { ...ctx.query, ...ctx.request.body };
+                const ret = await this.apply({ action, params });
+                ctx.res.writeHead(200).end(ret);
+            }
+            catch (e) {
+                ctx.res.writeHead(500).end(e.message);
+            }
+        }
+        else {
+            ctx.res.writeHead(405).end();
+        }
+    }
+    /**
+     * 处理ws消息
+     */
+    _webSocketHandler(ws) {
+        ws.on("message", async (msg) => {
+            this.logger.debug(" 收到ws消息：" + msg);
+            var data;
+            try {
+                data = JSON.parse(String(msg));
+                let ret;
+                if (data.action.startsWith(".handle_quick_operation")) {
+                    const event = data.params.context, res = data.params.operation;
+                    this._quickOperate(event, res);
+                    ret = JSON.stringify({
+                        retcode: 0,
+                        status: "async",
+                        data: null,
+                        error: null,
+                        echo: data.echo
+                    });
+                }
+                else {
+                    ret = await this.apply(data);
+                }
+                ws.send(ret);
+            }
+            catch (e) {
+                let code, message;
+                if (e instanceof onebot_1.NotFoundError) {
+                    code = 1404;
+                    message = "不支持的api";
+                }
+                else {
+                    code = 1400;
+                    message = "请求格式错误";
+                }
+                ws.send(JSON.stringify({
+                    retcode: code,
+                    status: "failed",
+                    data: null,
+                    error: {
+                        code, message
+                    },
+                    echo: data?.echo
+                }));
+            }
+        });
+        ws.send(JSON.stringify(V11.genMetaEvent(this.client.uin, "connect")));
+        ws.send(JSON.stringify(V11.genMetaEvent(this.client.uin, "enable")));
+    }
+    /**
+     * 创建反向ws
+     */
+    _createWsr(url) {
+        const timestmap = Date.now();
+        const headers = {
+            "X-Self-ID": String(this.client.uin),
+            "X-Client-Role": "Universal",
+            "User-Agent": "OneBot",
+        };
+        if (this.config.access_token)
+            headers.Authorization = "Bearer " + this.config.access_token;
+        const ws = new ws_1.WebSocket(url, { headers });
+        ws.on("error", (err) => {
+            this.logger.error(err.message);
+        });
+        ws.on("open", () => {
+            this.logger.info(`反向ws(${url})连接成功。`);
+            this.wsr.add(ws);
+            this._webSocketHandler(ws);
+        });
+        ws.on("close", (code) => {
+            this.wsr.delete(ws);
+            if (timestmap < this.timestamp)
+                return;
+            this.logger.warn(`反向ws(${url})被关闭，关闭码${code}，将在${this.config.reconnect_interval}秒后尝试重连。`);
+            setTimeout(() => {
+                if (timestmap < this.timestamp)
+                    return;
+                this._createWsr(url);
+            }, this.config.reconnect_interval * 1000);
+        });
+        return ws;
+    }
+    /**
+     * 快速操作
+     */
+    _quickOperate(event, res) {
+        if (event.post_type === "message") {
+            if (res.reply) {
+                if (event.message_type === "discuss")
+                    return;
+                const action = event.message_type === "private" ? "sendPrivateMsg" : "sendGroupMsg";
+                const id = event.message_type === "private" ? event.user_id : event.group_id;
+                this.client[action](id, res.reply, res.auto_escape);
+            }
+            if (event.message_type === "group") {
+                if (res.delete)
+                    this.client.deleteMsg(event.message_id);
+                if (res.kick && !event.anonymous)
+                    this.client.setGroupKick(event.group_id, event.user_id, res.reject_add_request);
+                if (res.ban)
+                    this.client.setGroupBan(event.group_id, event.user_id, res.ban_duration > 0 ? res.ban_duration : 1800);
+            }
+        }
+        if (event.post_type === "request" && "approve" in res) {
+            const action = event.request_type === "friend" ? "setFriendAddRequest" : "setGroupAddRequest";
+            this.client[action](event.flag, res.approve, res.reason ? res.reason : "", !!res.block);
+        }
+    }
+    /**
+     * 调用api
+     */
+    async apply(req) {
+        let { action, params, echo } = req;
+        action = (0, utils_1.toLine)(action);
+        let is_async = action.includes("_async");
+        if (is_async)
+            action = action.replace("_async", "");
+        let is_queue = action.includes("_rate_limited");
+        if (is_queue)
+            action = action.replace("_rate_limited", "");
+        if (action === 'send_msg') {
+            if (["private", "group", "discuss"].includes(params.message_type)) {
+                action = "send_" + params.message_type + "_msg";
+            }
+            else if (params.user_id)
+                action = "send_private_msg";
+            else if (params.group_id)
+                action = "send_group_msg";
+            else if (params.discuss_id)
+                action = "send_discuss_msg";
+            else
+                throw new Error('required message_type or input (user_id/group_id)');
+        }
+        const method = (0, utils_1.toHump)(action);
+        if (Reflect.has(this.action, method)) {
+            const ARGS = String(Reflect.get(this.action, method)).match(/\(.*\)/)?.[0]
+                .replace("(", "")
+                .replace(")", "")
+                .split(",")
+                .filter(Boolean).map(v => v.replace(/=.+/, "").trim());
+            const args = [];
+            for (let k of ARGS) {
+                if (Reflect.has(params, k)) {
+                    if (onebot_1.BOOLS.includes(k))
+                        params[k] = (0, utils_1.toBool)(params[k]);
+                    if (k === 'message') {
+                        if (typeof params[k] === 'string') {
+                            params[k] = (0, icqq_cq_enable_1.fromCqcode)(params[k]);
+                        }
+                        else {
+                            params[k] = (0, icqq_cq_enable_1.fromSegment)(params[k]);
+                        }
+                    }
+                    args.push(params[k]);
+                }
+            }
+            let ret, result;
+            if (is_queue) {
+                this._queue.push({ method, args });
+                this._runQueue();
+                result = V11.success(null, 0, true);
+            }
+            else {
+                try {
+                    ret = this.action[method].apply(this, args);
+                }
+                catch (e) {
+                    return JSON.stringify(V11.error(e.message));
+                }
+                if (ret instanceof Promise) {
+                    if (is_async) {
+                        result = V11.success(null, 0, true);
+                    }
+                    else {
+                        result = V11.success(await ret, 0, false);
+                    }
+                }
+                else {
+                    result = V11.success(await ret, 0, false);
+                }
+            }
+            if (result.data instanceof Map)
+                result.data = [...result.data.values()];
+            if (echo) {
+                result.echo = echo;
+            }
+            return JSON.stringify(result);
+        }
+        else
+            throw new onebot_1.NotFoundError();
+    }
+    /**
+     * 限速队列调用
+     */
+    async _runQueue() {
+        if (this.queue_running)
+            return;
+        while (this._queue.length > 0) {
+            this.queue_running = true;
+            const task = this._queue.shift();
+            const { method, args } = task;
+            this.action[method].apply(this, args);
+            await new Promise((resolve) => {
+                setTimeout(resolve, this.config.rate_limit_interval * 1000);
+            });
+            this.queue_running = false;
+        }
+    }
+}
+exports.V11 = V11;
+(function (V11) {
+    function success(data, retcode = 0, pending) {
+        return {
+            retcode,
+            status: pending ? 'async' : 'success',
+            data,
+            error: null
+        };
+    }
+    V11.success = success;
+    function error(error, retcode = 1) {
+        return {
+            retcode,
+            status: 'error',
+            data: null,
+            error
+        };
+    }
+    V11.error = error;
+    V11.defaultConfig = {
+        heartbeat: 3,
+        access_token: '',
+        post_timeout: 15,
+        secret: '',
+        rate_limit_interval: 4,
+        post_message_format: 'string',
+        reconnect_interval: 3,
+        use_http: true,
+        enable_cors: true,
+        use_ws: true,
+        http_reverse: [],
+        ws_reverse: []
+    };
+    function genMetaEvent(uin, type) {
+        return {
+            self_id: uin,
+            time: Math.floor(Date.now() / 1000),
+            post_type: "meta_event",
+            meta_event_type: "lifecycle",
+            sub_type: type,
+        };
+    }
+    V11.genMetaEvent = genMetaEvent;
+})(V11 = exports.V11 || (exports.V11 = {}));

package/lib/service/V12/action/common.d.ts

@@ -0,0 +1,32 @@
+import { V12 } from '../../../service/V12';
+import { OnlineStatus } from "icqq";
+import { Action } from "./";
+import { V11 } from "../../../service/V11";
+export declare class CommonAction {
+    sendMsg(): void;
+    /**
+     * 撤回消息
+     * @param message_id {string} 消息id
+     */
+    deleteMsg(this: V12, message_id: string): Promise<boolean>;
+    getSelfInfo(this: V12): {
+        user_id: number;
+        nickname: string;
+    };
+    getStatus(this: V12): {
+        online: OnlineStatus;
+        good: boolean;
+    };
+    getLatestEvents(this: V12, limit?: number, timout?: number): Promise<V12.Payload<keyof Action>[]>;
+    getVersion(this: V12): {
+        impl: string;
+        platform: string;
+        version: string;
+        onebot_version: string;
+    };
+    submitSlider(this: V11, ticket: string): void;
+    submitSmsCode(this: V11, code: string): void;
+    sendSmsCode(this: V11): void;
+    login(this: V11, password?: string): Promise<unknown>;
+    getSupportedActions(this: V12): string[];
+}

package/lib/service/V12/action/common.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonAction = void 0;
+const icqq_1 = require("icqq");
+const onebot_1 = require("../../../onebot");
+const utils_1 = require("../../../utils");
+class CommonAction {
+    sendMsg() { }
+    /**
+     * 撤回消息
+     * @param message_id {string} 消息id
+     */
+    deleteMsg(message_id) {
+        return this.client.deleteMsg(message_id);
+    }
+    getSelfInfo() {
+        return {
+            user_id: this.client.uin,
+            nickname: this.client.nickname
+        };
+    }
+    getStatus() {
+        return {
+            online: this.client.status = icqq_1.OnlineStatus.Online,
+            good: this.oneBot.status === onebot_1.OneBotStatus.Good
+        };
+    }
+    getLatestEvents(limit = 0, timout = 0) {
+        return new Promise(resolve => {
+            if (!this.history.length && timout !== 0) {
+                return setTimeout(() => resolve(this.action.getLatestEvents.apply(this, [limit, timout])), timout * 1000);
+            }
+            return resolve(this.history.reverse().filter((_, i) => limit === 0 ? true : i < limit));
+        });
+    }
+    getVersion() {
+        return {
+            impl: 'icqq_onebot',
+            platform: 'qq',
+            version: '0.0.1',
+            onebot_version: '12'
+        };
+    }
+    submitSlider(ticket) {
+        return this.client.submitSlider(ticket);
+    }
+    submitSmsCode(code) {
+        return this.client.submitSmsCode(code);
+    }
+    sendSmsCode() {
+        return this.client.sendSmsCode();
+    }
+    login(password) {
+        const _this = this;
+        return new Promise(async (resolve) => {
+            const timer = setTimeout(() => {
+                resolve('登录超时');
+            }, 5000);
+            function receiveQrcode(event) {
+                _this.client.off('system.login.device', receiveDevice);
+                _this.client.off('system.login.slider', receiveSlider);
+                _this.client.off('system.online', closeListen);
+                clearTimeout(timer);
+                resolve(event);
+            }
+            function receiveDevice(event) {
+                _this.client.off('system.login.qrcode', receiveQrcode);
+                _this.client.off('system.login.slider', receiveSlider);
+                _this.client.off('system.online', closeListen);
+                clearTimeout(timer);
+                resolve(event);
+            }
+            function receiveError(event) {
+                clearTimeout(timer);
+                resolve(event);
+            }
+            function receiveSlider(event) {
+                _this.client.off('system.login.qrcode', receiveQrcode);
+                _this.client.off('system.login.device', receiveDevice);
+                _this.client.off('system.online', closeListen);
+                clearTimeout(timer);
+                resolve(event);
+            }
+            function closeListen() {
+                _this.client.off('system.login.slider', receiveSlider);
+                _this.client.off('system.login.qrcode', receiveQrcode);
+                _this.client.off('system.login.device', receiveDevice);
+                clearTimeout(timer);
+                resolve('登录成功');
+            }
+            this.client.once('system.login.qrcode', receiveQrcode);
+            this.client.once('system.login.device', receiveDevice);
+            this.client.once('system.login.slider', receiveSlider);
+            this.client.once('system.login.error', receiveError);
+            this.client.once('system.online', closeListen);
+            await this.client.login(password).catch(() => resolve('登录失败'));
+        });
+    }
+    getSupportedActions() {
+        return [...new Set((0, utils_1.getProperties)(this.action))].filter(key => {
+            return key !== 'constructor';
+        }).map(utils_1.toLine);
+    }
+}
+exports.CommonAction = CommonAction;

package/lib/service/V12/action/friend.d.ts

@@ -0,0 +1,13 @@
+import { V12 } from "../index";
+import { Sendable } from "icqq";
+export declare class FriendAction {
+    getUserInfo(this: V12, user_id: number): Promise<{
+        user_id: number;
+        nickname: string;
+        sex: import("icqq").Gender;
+        age: number;
+        area: string;
+    }>;
+    getFriendList(this: V12): Map<number, import("icqq").FriendInfo>;
+    sendPrivateMsg(this: V12, user_id: number, message: Sendable): Promise<import("icqq").MessageRet>;
+}

package/lib/service/V12/action/friend.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FriendAction = void 0;
+class FriendAction {
+    getUserInfo(user_id) {
+        return this.client.getStrangerInfo(user_id);
+    }
+    getFriendList() {
+        return this.client.getFriendList();
+    }
+    sendPrivateMsg(user_id, message) {
+        return this.client.sendPrivateMsg(user_id, message);
+    }
+}
+exports.FriendAction = FriendAction;