onebots 0.0.1

package/lib/service/V12/index.js

@@ -0,0 +1,530 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V12 = void 0;
+const path_1 = require("path");
+const onebot_1 = require("../../onebot");
+const action_1 = require("./action");
+const events_1 = require("events");
+const url_1 = require("url");
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const ws_1 = require("ws");
+const icqq_cq_enable_1 = require("icqq-cq-enable");
+const utils_1 = require("../../utils");
+const db_1 = require("../../db");
+const app_1 = require("../../server/app");
+class V12 extends events_1.EventEmitter {
+    constructor(oneBot, client, config) {
+        super();
+        this.oneBot = oneBot;
+        this.client = client;
+        this.config = config;
+        this.version = 'V12';
+        this.timestamp = Date.now();
+        this.wsr = new Set();
+        this.db = new db_1.Db((0, path_1.join)(app_1.App.configDir, 'data', this.client.uin + '.json'));
+        if (!this.history)
+            this.db.set('eventBuffer', []);
+        this.action = new action_1.Action();
+        this.logger = this.oneBot.app.getLogger(this.client.uin, this.version);
+    }
+    get history() {
+        return this.db.get('eventBuffer');
+    }
+    start(path) {
+        this.path = `/${this.client.uin}`;
+        if (path)
+            this.path += path;
+        if (this.config.use_http) {
+            const config = typeof this.config.use_http === 'boolean' ? {} : this.config.use_http || {};
+            this.startHttp({
+                access_token: this.config.access_token,
+                event_enabled: true,
+                event_buffer_size: 50,
+                ...config
+            });
+        }
+        if (this.config.use_ws) {
+            const config = typeof this.config.use_ws === 'boolean' ? {} : this.config.use_ws || {};
+            this.startWs({
+                access_token: this.config.access_token,
+                ...config
+            });
+        }
+        this.config.webhook.forEach(config => {
+            if (typeof config === 'string') {
+                config = {
+                    url: config,
+                    access_token: this.config.access_token,
+                };
+            }
+            else {
+                config = {
+                    access_token: this.config.access_token,
+                    ...config
+                };
+            }
+            this.startWebhook(config);
+        });
+        this.config.ws_reverse.forEach(config => {
+            if (typeof config === 'string') {
+                config = {
+                    url: config,
+                    access_token: this.config.access_token,
+                };
+            }
+            else {
+                config = {
+                    access_token: this.config.access_token,
+                    ...config
+                };
+            }
+            this.startWsReverse(config);
+        });
+        if (this.config.heartbeat) {
+            this.heartbeat = setInterval(() => {
+                this.dispatch({
+                    self_id: this.client.uin,
+                    time: Math.floor(Date.now() / 1000),
+                    type: "meta",
+                    detail_type: "heartbeat",
+                    interval: this.config.heartbeat * 1000,
+                    status: this.action.getStatus.apply(this)
+                });
+            }, this.config.heartbeat * 1000);
+        }
+    }
+    startHttp(config) {
+        this.oneBot.app.router.all(new RegExp(`^${this.path}/(.*)$`), (ctx) => this._httpRequestHandler(ctx, config));
+        this.logger.mark(`开启http服务器成功，监听:http://127.0.0.1:${this.oneBot.app.config.port}${this.path}`);
+        this.on('dispatch', (payload) => {
+            if (!['message', 'notice', 'request', 'system'].includes(payload.type))
+                return;
+            if (config.event_enabled) {
+                this.history.push(payload);
+                if (config.event_buffer_size !== 0 && this.history.length > config.event_buffer_size)
+                    this.history.shift();
+            }
+        });
+    }
+    startWebhook(config) {
+        this.on('dispatch', (unserialized) => {
+            const serialized = JSON.stringify(unserialized);
+            const options = {
+                method: "POST",
+                timeout: this.config.request_timeout * 1000,
+                headers: {
+                    "Content-Type": "application/json",
+                    "Content-Length": Buffer.byteLength(serialized),
+                    "X-Self-ID": String(this.client.uin),
+                    "User-Agent": "OneBot",
+                },
+            };
+            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(config) {
+        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 (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 ${config.access_token}`)
+                    return ws.close(1002, "wrong access token");
+            }
+            this._webSocketHandler(ws);
+        });
+        this.on('dispatch', (unserialized) => {
+            const serialized = JSON.stringify(unserialized);
+            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(config) {
+        const ws = this._createWsr(config.url, config);
+        this.on('dispatch', (unserialized) => {
+            if (this.wsr.has(ws)) {
+                ws.send(JSON.stringify(unserialized));
+            }
+        });
+    }
+    stop() {
+        return this.client.logout();
+    }
+    dispatch(data = {}) {
+        if (!data)
+            data = {};
+        if (!data.post_type) {
+            // @ts-ignore
+            data.sub_type = 'online';
+            if (data.image) {
+                // @ts-ignore
+                data.system_type = 'login';
+                // @ts-ignore
+                data.sub_type = 'qrcode';
+            }
+            else if (data.url) {
+                // @ts-ignore
+                data.system_type = 'login';
+                // @ts-ignore
+                data.sub_type = 'slider';
+                if (data.phone) {
+                    // @ts-ignore
+                    data.sub_type = 'device';
+                }
+            }
+            else if (data.message) {
+                // @ts-ignore
+                data.system_type = 'login';
+                // @ts-ignore
+                data.sub_type = 'error';
+            }
+        }
+        const payload = {
+            id: (0, utils_1.uuid)(),
+            impl: 'icqq_onebot',
+            platform: 'qq',
+            self_id: `${this.client.uin}`,
+            type: data.post_type || 'meta',
+            detail_type: data.message_type || data.notice_type || data.request_type || data.system_type,
+            ...data,
+        };
+        if (payload.type === 'notice') {
+            switch (payload.detail_type) {
+                case 'friend':
+                    payload.detail_type += payload.sub_type;
+                    break;
+                case 'group':
+                    if (['increase', 'decrease'].includes(payload.sub_type))
+                        payload.detail_type = 'group_member_' + payload.sub_type;
+                    else if (payload.sub_type === 'recall')
+                        payload.detail_type = 'group_message_delete';
+            }
+        }
+        this.emit('dispatch', payload);
+    }
+    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", "");
+        if (action === 'send_msg') {
+            if (["private", "group", "discuss", 'channel'].includes(params.detail_type)) {
+                action = "send_" + params.detail_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 if (params.channel_id && params.guild_id)
+                action = "send_guild_msg";
+            else
+                throw new Error('required detail_type or input (user_id/group_id/(guild_id and channel_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;
+            try {
+                ret = this.action[method].apply(this, args);
+            }
+            catch (e) {
+                return JSON.stringify(V12.error(e.message));
+            }
+            if (ret instanceof Promise) {
+                if (is_async) {
+                    result = V12.success(null, 0);
+                }
+                else {
+                    result = V12.success(await ret, 0);
+                }
+            }
+            else {
+                result = V12.success(await ret, 0);
+            }
+            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 _httpRequestHandler(ctx, config) {
+        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 (config.access_token) {
+            if (ctx.headers["authorization"]) {
+                if (ctx.headers["authorization"] !== `Bearer ${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();
+        }
+    }
+    /**
+     * 快速操作
+     */
+    _quickOperate(event, res) {
+        if (event.type === "message") {
+            if (res.reply) {
+                if (event.detail_type === "discuss")
+                    return;
+                const action = event.detail_type === "private" ? "sendPrivateMsg" : "sendGroupMsg";
+                const id = event.detail_type === "private" ? event.user_id : event.group_id;
+                this.client[action](id, res.reply, res.auto_escape);
+            }
+            if (event.detail_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.type === "request" && "approve" in res) {
+            const action = event.detail_type === "friend" ? "setFriendAddRequest" : "setGroupAddRequest";
+            this.client[action](event.flag, res.approve, res.reason ? res.reason : "", !!res.block);
+        }
+    }
+    /**
+     * 创建反向ws
+     */
+    _createWsr(url, config) {
+        const timestmap = Date.now();
+        const headers = {
+            "X-Self-ID": String(this.client.uin),
+            "X-Client-Role": "Universal",
+            "User-Agent": "OneBot",
+        };
+        if (config.access_token)
+            headers.Authorization = "Bearer " + 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, config);
+            }, this.config.reconnect_interval * 1000);
+        });
+        return ws;
+    }
+    /**
+     * 处理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: "ok",
+                        data: null,
+                        message: 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 = 10002;
+                    message = "不支持的api";
+                }
+                else {
+                    code = 10003;
+                    message = "请求格式错误";
+                }
+                ws.send(JSON.stringify({
+                    retcode: code,
+                    status: "failed",
+                    data: null,
+                    error: {
+                        code, message
+                    },
+                    echo: data?.echo
+                }));
+            }
+        });
+        this.dispatch(V12.genMetaEvent(this.client.uin, "connect"));
+        this.dispatch(V12.genMetaEvent(this.client.uin, "enable"));
+    }
+}
+exports.V12 = V12;
+(function (V12) {
+    V12.defaultConfig = {
+        heartbeat: 3,
+        access_token: '',
+        request_timeout: 15,
+        reconnect_interval: 3,
+        enable_cors: true,
+        use_http: true,
+        use_ws: true,
+        webhook: [],
+        ws_reverse: []
+    };
+    function success(data, retcode = 0, echo) {
+        return {
+            retcode,
+            status: retcode === 0 ? 'ok' : 'failed',
+            data,
+            message: '',
+            echo
+        };
+    }
+    V12.success = success;
+    function error(message, retcode = 10001, echo) {
+        return {
+            retcode,
+            status: 'failed',
+            data: null,
+            message,
+            echo
+        };
+    }
+    V12.error = error;
+    function genMetaEvent(uin, type) {
+        return {
+            self_id: uin,
+            time: Math.floor(Date.now() / 1000),
+            type: "meta",
+            detail_type: "lifecycle",
+            sub_type: type,
+        };
+    }
+    V12.genMetaEvent = genMetaEvent;
+})(V12 = exports.V12 || (exports.V12 = {}));

package/lib/types.d.ts

@@ -0,0 +1,3 @@
+export declare type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal" | "mark" | "off";
+export declare type Dispose = () => any;
+export declare type MayBeArray<T extends any> = T | T[];

package/lib/types.js

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

package/lib/utils.d.ts

@@ -0,0 +1,13 @@
+export declare function deepMerge<T extends any>(base: T, ...from: T[]): T;
+export declare function deepClone<T extends any>(obj: T): T;
+export declare function pick<T, K extends keyof T>(source: T, keys?: Iterable<K>, forced?: boolean): Pick<T, K>;
+export declare function omit<T, K extends keyof T>(source: T, keys?: Iterable<K>): Omit<T, K>;
+export interface Class {
+    new (...args: any[]): any;
+}
+export declare function Mixin(base: Class, ...classes: Class[]): Class;
+export declare function toHump(action: string): string;
+export declare function toLine(name: string): string;
+export declare function toBool(v: any): boolean;
+export declare function uuid(): string;
+export declare function getProperties(obj: any): any;

package/lib/utils.js

@@ -0,0 +1,139 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProperties = exports.uuid = exports.toBool = exports.toLine = exports.toHump = exports.Mixin = exports.omit = exports.pick = exports.deepClone = exports.deepMerge = void 0;
+// 合并对象/数组
+const crypto = __importStar(require("crypto"));
+function deepMerge(base, ...from) {
+    if (from.length === 0) {
+        return base;
+    }
+    if (typeof base !== 'object') {
+        return base;
+    }
+    if (Array.isArray(base)) {
+        return base.concat(...from);
+    }
+    for (const item of from) {
+        for (const key in item) {
+            if (base.hasOwnProperty(key)) {
+                if (typeof base[key] === 'object') {
+                    base[key] = deepMerge(base[key], item[key]);
+                }
+                else {
+                    base[key] = item[key];
+                }
+            }
+            else {
+                base[key] = item[key];
+            }
+        }
+    }
+    return base;
+}
+exports.deepMerge = deepMerge;
+// 深拷贝
+function deepClone(obj) {
+    if (typeof obj !== 'object')
+        return obj;
+    if (!obj)
+        return obj;
+    //判断拷贝的obj是对象还是数组
+    if (Array.isArray(obj))
+        return obj.map((item) => deepClone(item));
+    const objClone = {};
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            if (obj[key] && typeof obj[key] === "object") {
+                objClone[key] = deepClone(obj[key]);
+            }
+            else {
+                objClone[key] = obj[key];
+            }
+        }
+    }
+    return objClone;
+}
+exports.deepClone = deepClone;
+function pick(source, keys, forced) {
+    if (!keys)
+        return { ...source };
+    const result = {};
+    for (const key of keys) {
+        if (forced || key in source)
+            result[key] = source[key];
+    }
+    return result;
+}
+exports.pick = pick;
+function omit(source, keys) {
+    if (!keys)
+        return { ...source };
+    const result = { ...source };
+    for (const key of keys) {
+        Reflect.deleteProperty(result, key);
+    }
+    return result;
+}
+exports.omit = omit;
+function Mixin(base, ...classes) {
+    classes.forEach(ctr => {
+        Object.getOwnPropertyNames(ctr.prototype).forEach(name => {
+            if (name === 'constructor')
+                return;
+            base.prototype[name] = ctr.prototype[name];
+        });
+    });
+    return base;
+}
+exports.Mixin = Mixin;
+function toHump(action) {
+    return action.replace(/_[\w]/g, (s) => {
+        return s[1].toUpperCase();
+    });
+}
+exports.toHump = toHump;
+function toLine(name) {
+    return name.replace(/([A-Z])/g, "_$1").toLowerCase();
+}
+exports.toLine = toLine;
+function toBool(v) {
+    if (v === "0" || v === "false")
+        v = false;
+    return Boolean(v);
+}
+exports.toBool = toBool;
+function uuid() {
+    let hex = crypto.randomBytes(16).toString("hex");
+    return hex.substr(0, 8) + "-" + hex.substr(8, 4) + "-" + hex.substr(12, 4) + "-" + hex.substr(16, 4) + "-" + hex.substr(20);
+}
+exports.uuid = uuid;
+function getProperties(obj) {
+    if (obj.__proto__ === null) { //说明该对象已经是最顶层的对象
+        return [];
+    }
+    return Object.getOwnPropertyNames(obj).concat(getProperties(obj.__proto__));
+}
+exports.getProperties = getProperties;