node-karin 0.12.0 → 0.12.2-5.pr.206.027f2f2

package/lib/core/process/process.js

@@ -1,96 +0,0 @@
-import { karin } from '../karin/karin.js';
-import { logger, common, config } from '../../utils/index.js';
-/**
- * 处理基本事件
- */
-export default class Process {
-    /**
-     * 进程初始化
-     */
-    static async process() {
-        /**
-         * 监听挂起信号 在终端关闭时触发
-         */
-        process.once('SIGHUP', async (code) => await this.exit(code));
-        /**
-         * 监听中断信号 用户按下 Ctrl + C 时触发
-         */
-        process.once('SIGINT', async (code) => await this.exit(code));
-        /**
-         * 监听终止信号 程序正常退出时触发
-         */
-        process.once('SIGTERM', async (code) => await this.exit(code));
-        /**
-         * 监听退出信号 windows下程序正常退出时触发
-         */
-        process.once('SIGBREAK', async (code) => await this.exit(code));
-        /**
-         * 监听退出信号 与 SIGINT 类似，但会生成核心转储
-         */
-        process.once('SIGQUIT', async (code) => await this.exit(code));
-        /**
-         * 监听退出信号 Node.js进程退出时触发
-         */
-        process.once('exit', async (code) => await this.exit(code));
-        /**
-         * 捕获警告
-         */
-        process.on('warning', warning => karin.emit('warn', warning));
-        /**
-         * 捕获错误
-         */
-        process.on('uncaughtException', error => karin.emit('error', error));
-        /**
-         * 捕获未处理的Promise错误
-         */
-        process.on('unhandledRejection', error => karin.emit('error', error));
-        return this;
-    }
-    /**
-     * 检查后台进程
-     */
-    static async check() {
-        const host = `http://127.0.0.1:${config.Server.http.port}/api`;
-        /**
-         * 使用api来检查后台
-         */
-        const res = await common.axios(host + '/ping', 'get', { timeout: 2000 });
-        if (!res)
-            return this;
-        logger.mark(logger.red('检测到后台进程 正在关闭'));
-        /** 发退出信号 */
-        await common.axios(host + '/exit', 'get', { timeout: 10 });
-        for (let i = 0; i < 50; i++) {
-            const res = await common.axios(host + '/ping', 'get', { timeout: 100 });
-            /** 请求成功继续循环 */
-            if (res)
-                continue;
-            /** 请求异常即代表后台进程已关闭 */
-            logger.mark(logger.green('后台进程已关闭'));
-            return this;
-        }
-        /**
-         * 走到这里说明后台关闭失败
-         * 根据配置文件判断是否继续
-         */
-        logger.error(logger.red(`后台进程关闭失败，请检查是否有进程正在占用端口${config.Server.http.port}`));
-        await this.exit();
-        return this;
-    }
-    /**
-     * 退出Karin
-     * @param code 退出码
-     */
-    static async exit(code = 0) {
-        try {
-            const { redis } = await import('../../db/index.js');
-            if (redis && redis.save)
-                await redis.save();
-            logger.mark(`Karin 已停止运行 运行时间：${common.uptime()} 退出码：${code || '未知'}`);
-        }
-        finally {
-            process.exit();
-        }
-    }
-}
-Process.process();

package/lib/core/server/server.d.ts

@@ -1,25 +0,0 @@
-import { WebSocketServer } from 'ws';
-import { Express } from 'express';
-import { Server as ServerType, ServerResponse, IncomingMessage } from 'http';
-export declare const server: {
-    reg: RegExp;
-    list: string[];
-    app: Express;
-    server: ServerType<typeof IncomingMessage, typeof ServerResponse>;
-    WebSocketServer: WebSocketServer;
-    RegExp: RegExp;
-    /**
-     * 监听WebSocket连接并初始化http服务器
-     */
-    init(): Promise<false | any>;
-    /**
-     * HTTP渲染器
-     */
-    static(): void;
-    /**
-     * 构建静态资源路径
-     */
-    staticPath(): Promise<void>;
-    /** 重启当前HTTP服务器 */
-    "__#15@#restartServer"(): Promise<void>;
-};

package/lib/core/server/server.js

@@ -1,295 +0,0 @@
-import fs from 'fs';
-import { level } from '../../db/index.js';
-import { WebSocketServer } from 'ws';
-import { createServer } from 'http';
-import { karin } from '../karin/karin.js';
-import Process from '../process/process.js';
-import express from 'express';
-import { exec, config, logger, common } from '../../utils/index.js';
-import { AdapterOneBot11 } from '../../adapter/onebot/11/index.js';
-import { render, HttpRenderer, Wormhole, RenderClient } from '../../render/index.js';
-export const server = new (class Server {
-    reg;
-    list;
-    app;
-    server;
-    WebSocketServer;
-    RegExp;
-    constructor() {
-        this.reg = /(?:)/;
-        this.list = [];
-        this.app = express();
-        this.server = createServer(this.app);
-        this.WebSocketServer = new WebSocketServer({ server: this.server });
-        this.RegExp = new RegExp(`(${process.cwd()}|${process.cwd().replace(/\\/g, '/')})`, 'g');
-    }
-    /**
-     * 监听WebSocket连接并初始化http服务器
-     */
-    async init() {
-        try {
-            /** 防止多进程端口冲突 启动失败 */
-            await Process.check();
-            level.open();
-            this.WebSocketServer.on('connection', (socket, request) => {
-                const path = request.url;
-                const headers = request.headers;
-                logger.debug('[反向WS]', path, JSON.stringify(headers, null, 2));
-                try {
-                    const Adapter = karin.getAdapter(path);
-                    if (!Adapter) {
-                        logger.error(`[反向WS] 适配器不存在：${path}`);
-                        return socket.close();
-                    }
-                    const KarinAdapter = new Adapter();
-                    if (typeof KarinAdapter?.server === 'function') {
-                        KarinAdapter.server(socket, request);
-                    }
-                }
-                catch (error) {
-                    logger.error(`[反向WS] 注册适配器发生错误：${path}`, error.stack || error.message || error);
-                    socket.close();
-                }
-            });
-            /** GET接口 - 获取当前启动信息 */
-            this.app.get('/api/ping', (req, res) => {
-                /** 只允许本机ip访问 */
-                if (req.hostname === 'localhost' || req.hostname === '127.0.0.1') {
-                    const data = {
-                        pm2_id: process.env.pm_id || '',
-                        uptime: process.uptime(),
-                        karin_app_mode: process.env.karin_app_mode,
-                        karin_app_lang: process.env.karin_app_lang,
-                        karin_app_runner: process.env.karin_app_runner,
-                        karin_app_start_count: process.env.karin_app_start_count,
-                    };
-                    res.json(data);
-                }
-                else {
-                    res.status(403).json({ error: '禁止访问', message: '无效的请求' });
-                }
-            });
-            /** GET接口 - 退出当前进程 */
-            this.app.get('/api/exit', async (req) => {
-                /** 只允许本机ip访问 */
-                if (req.hostname === 'localhost' || req.hostname === '127.0.0.1') {
-                    logger.mark('[服务器][HTTP] 收到退出请求，即将退出');
-                    /** 关闭服务器 */
-                    karin.emit('exit.grpc');
-                    this.server.close();
-                    try {
-                        await level.close();
-                        const redis = (await import('../../db/index.js')).redis;
-                        if (redis && redis.id === 'RedisLevel')
-                            await redis.level.close();
-                    }
-                    catch (error) {
-                        logger.error('[服务器][HTTP] 关闭数据库失败');
-                        logger.error(error);
-                    }
-                    /** 如果是pm2 获取当前pm2ID 使用 */
-                    if (process.env.pm_id)
-                        await exec(`pm2 delete ${process.env.pm_id}`);
-                    /** 正常启动的进程 */
-                    process.exit();
-                }
-            });
-            /** 控制台适配器 */
-            this.app.get('/api/input', (req, res) => {
-                const name = req.query.name;
-                const token = req.query.token;
-                if (!name || !token) {
-                    logger.error('[HTTP][input] 缺少参数', req.query);
-                    return res.status(403).json({ error: '禁止访问', message: '缺少参数' });
-                }
-                // 禁止键入向上级目录
-                if (name.includes('/')) {
-                    logger.error('[HTTP][input] 无效的文件名', name);
-                    return res.status(403).json({ error: '禁止访问', message: '无效的文件名' });
-                }
-                const CfgToken = config.Config.AdapterInput.token;
-                if (CfgToken === 'AdapterInput' || CfgToken !== token) {
-                    logger.error('[HTTP][input] 无效的令牌', token);
-                    return res.status(403).json({ error: '禁止访问', message: '无效的令牌' });
-                }
-                const file = process.cwd() + `/temp/input/${name}`;
-                if (!fs.existsSync(file)) {
-                    logger.error('[HTTP][input] 文件不存在', file);
-                    return res.status(404).json({ error: '文件不存在', message: '找不到指定文件' });
-                }
-                logger.info(`${logger.yellow('[HTTP][input]')} ${logger.green(token)} file:${file}`);
-                res.sendFile(file);
-            });
-            /** 监听端口 */
-            const { host, port } = config.Server.http;
-            this.server.listen(port, host, () => {
-                logger.mark('[服务器][启动成功][HTTP]: ' + logger.green(`http://${host}:${port}`));
-            });
-            karin.once('restart.http', () => {
-                logger.mark('[服务器][重启][HTTP] 正在重启HTTP服务器...');
-                this.#restartServer();
-            });
-            const renderCfg = config.Server.websocket.render;
-            if (Array.isArray(renderCfg) && renderCfg.length) {
-                for (const url of renderCfg) {
-                    new RenderClient(url).start();
-                }
-            }
-            const Onebot11 = config.Server.websocket.OneBot11Host;
-            if (Array.isArray(Onebot11) && Onebot11.length) {
-                for (const connect of Onebot11) {
-                    new AdapterOneBot11().client(connect);
-                }
-            }
-            const { enable, WormholeClient } = config.Server.HttpRender;
-            if (enable) {
-                this.static();
-                if (WormholeClient) {
-                    Wormhole();
-                    return this;
-                }
-                const { host, post, token } = config.Server.HttpRender;
-                /** 注册渲染器 */
-                const rd = new HttpRenderer(host, post, token);
-                render.app({ id: 'puppeteer', type: 'image', render: rd.render.bind(rd) });
-            }
-            return this;
-        }
-        catch (error) {
-            logger.error('初始化HTTP服务器失败: ', error);
-            return false;
-        }
-    }
-    /**
-     * HTTP渲染器
-     */
-    static() {
-        this.staticPath();
-        /** GET接口 - 渲染 */
-        this.app.get('/api/renderHtml', (req, res) => {
-            try {
-                let { html } = req.query;
-                if (!html)
-                    return res.status(404).send(JSON.stringify({ code: 404, msg: 'Not Found' }));
-                html = decodeURIComponent(html)
-                    .replace(/\\/g, '/')
-                    .replace(/^\.\//, '');
-                /** 判断是否为html文件且路径存在 */
-                if (!html.endsWith('.html') || !fs.existsSync(html)) {
-                    const not_found = config.Server.HttpRender.not_found;
-                    if (not_found.startsWith('http')) {
-                        return res.redirect(not_found);
-                    }
-                    else {
-                        return res.status(404).send(JSON.stringify({ code: 404, msg: not_found || '?' }));
-                    }
-                }
-                let content = fs.readFileSync(html, 'utf-8');
-                /** 处理所有绝对路径、相对路径 */
-                content = content.replace(this.RegExp, '');
-                res.send(content);
-            }
-            catch (e) {
-                logger.error('[服务器][GET接口 - 渲染]', e);
-                res.status(500).send(JSON.stringify({ code: 500, msg: 'Internal Server Error' }));
-            }
-        });
-        /** 拦截静态资源 防止恶意访问 */
-        this.app.use((req, res, next) => {
-            logger.debug(`[静态资源][${req.headers.host}] ${req.url}`);
-            /** 解码 */
-            req.url = decodeURIComponent(req.url);
-            req.url = req.url
-                .replace(/\\/g, '/')
-                .replace(/^\.\//, '')
-                .replace(/^(\.\.\/)+/, '');
-            /** 拦截非资源文件 */
-            this.reg.lastIndex = 0;
-            if (!this.reg.test(req.url)) {
-                logger.mark(`[${req.ip}][拦截非资源文件]`, req.url);
-                res.status(404).send(JSON.stringify({ code: 404, msg: 'Not Found' }));
-                return;
-            }
-            next();
-        });
-        /** 设置静态文件目录 */
-        this.app.use(express.static(process.cwd()));
-    }
-    /**
-     * 构建静态资源路径
-     */
-    async staticPath() {
-        this.list = [];
-        /** 读取./resources文件夹 */
-        const resDir = './resources';
-        const resdirs = fs.readdirSync(resDir);
-        for (const dir of resdirs) {
-            const file = `${resDir}/${dir}`;
-            if (common.isDir(file))
-                this.list.push(file.replace('.', ''));
-        }
-        /** 读取./temp/html下所有文件夹 */
-        const htmlDir = './temp/html';
-        const dirs = fs.readdirSync(htmlDir);
-        for (const dir of dirs) {
-            const file = `${htmlDir}/${dir}`;
-            if (common.isDir(file))
-                this.list.push(file.replace('.', ''));
-        }
-        /** 读取./plugins/xxx/resources下所有文件夹 */
-        const pluginsDir = './plugins';
-        const plugins = fs.readdirSync(pluginsDir);
-        for (const dir of plugins) {
-            /** 忽略不是karin-plugin-开头 */
-            if (!dir.startsWith('karin-plugin-'))
-                continue;
-            const file = `${pluginsDir}/${dir}`;
-            const resFile = `${file}/resources`;
-            /** 包含resources文件夹 */
-            if (common.isDir(file) && common.isDir(resFile))
-                this.list.push(resFile.replace('.', ''));
-            const componentsFile = `${file}/lib/components`;
-            /** 包含lib/components文件夹 兼容mys */
-            if (common.isDir(file) && common.isDir(componentsFile))
-                this.list.push(componentsFile.replace('.', ''));
-            /** 读取package.json 查找是否存在自定义资源文件入口 */
-            const pkgFile = `${file}/package.json`;
-            if (!common.exists(pkgFile))
-                continue;
-            const pkg = common.readJson(pkgFile);
-            if (!pkg?.karin?.static || !Array.isArray(pkg.karin.static))
-                continue;
-            /** 标准格式为 lib/test/xxxx */
-            for (let staticFile of pkg.karin.static) {
-                /** 不允许向上级目录 ../开头等 */
-                if (staticFile.startsWith('../'))
-                    continue;
-                /** ./开头去掉./ */
-                if (staticFile.startsWith('./'))
-                    staticFile = staticFile.slice(2);
-                this.list.push(`${file}/${staticFile}`);
-            }
-        }
-        this.reg = new RegExp(`(${this.list.join('|')})`, 'g');
-    }
-    /** 重启当前HTTP服务器 */
-    async #restartServer() {
-        try {
-            /** 断开所有 WebSocket 连接 */
-            for (const ws of this.WebSocketServer.clients)
-                ws.terminate();
-            /** 关闭当前HTTP服务器 */
-            this.server.close();
-            /** 延迟1秒 */
-            await common.sleep(1000);
-            /** 创建一个新的服务器实例 */
-            this.server = createServer(this.app);
-            this.WebSocketServer = new WebSocketServer({ server: this.server });
-            this.init();
-            this.static();
-        }
-        catch (err) {
-            logger.error('[服务器][重启失败]', err);
-        }
-    }
-})();

package/lib/db/index.d.ts

@@ -1,2 +0,0 @@
-export * from './level/level.js';
-export * from './redis/redis.js';

package/lib/db/index.js

@@ -1,2 +0,0 @@
-export * from './level/level.js';
-export * from './redis/redis.js';

package/lib/db/level/level.d.ts

@@ -1,19 +0,0 @@
-import { Level } from 'level';
-/**
- * @type {Level}
- */
-export default class LevelDB extends Level {
-    id: string;
-    constructor();
-    /**
-     * 对get方法进行重写 找不到数据时返回null
-     */
-    get(key: string): Promise<string>;
-    /**
-     * 增加set方法
-     * @param {string} key 键
-     * @param {object|string} value 值
-     */
-    set(key: string, value: string | object): Promise<void>;
-}
-export declare const level: LevelDB;

package/lib/db/level/level.js

@@ -1,36 +0,0 @@
-import { Level } from 'level';
-const path = process.cwd() + '/data/db/Level';
-/**
- * @type {Level}
- */
-export default class LevelDB extends Level {
-    id;
-    constructor() {
-        super(path, { valueEncoding: 'json' });
-        /**
-         * @type {'Level'} 唯一标识符 用于区分不同的数据库
-         */
-        this.id = 'Level';
-    }
-    /**
-     * 对get方法进行重写 找不到数据时返回null
-     */
-    async get(key) {
-        try {
-            const res = await super.get(key);
-            return res;
-        }
-        catch {
-            return '';
-        }
-    }
-    /**
-     * 增加set方法
-     * @param {string} key 键
-     * @param {object|string} value 值
-     */
-    async set(key, value) {
-        return await super.put(key, value);
-    }
-}
-export const level = new LevelDB();

package/lib/db/redis/redis.d.ts

@@ -1,2 +0,0 @@
-import { RedisClientType } from 'redis';
-export declare const redis: RedisClientType;

package/lib/db/redis/redis.js

@@ -1,135 +0,0 @@
-import { exec } from 'child_process';
-import RedisLevel from './redis_level.js';
-import { logger, config } from '../../utils/index.js';
-import { createClient, createCluster } from 'redis';
-class Redis {
-    id;
-    RunCmd;
-    constructor() {
-        this.id = 'redis';
-        this.RunCmd = '';
-    }
-    /**
-     * redis实例化
-     */
-    async start() {
-        const { host, port, username, password, db: database, cluster } = config.redis;
-        /** 集群模式 */
-        if (cluster && cluster.enable) {
-            const rootNodes = cluster.rootNodes.map((node) => ({ url: node }));
-            logger.debug('正在连接 Redis 集群...');
-            const { status, data } = await this.connectCluster(rootNodes);
-            if (status === 'ok') {
-                logger.info('Redis 集群连接成功');
-                return data;
-            }
-            logger.error(`Redis 集群建立连接失败：${logger.red(data)}`);
-            return false;
-        }
-        logger.debug(`正在连接 ${logger.green(`Redis://${host}:${port}/${database}`)}`);
-        const options = { socket: { host, port }, username, password, database };
-        /** 第一次连接 */
-        const { status, data } = await this.connect(options);
-        if (status === 'ok') {
-            logger.info('Redis 连接成功');
-            return data;
-        }
-        /** 第一次连接失败尝试拉起 windows直接降级 */
-        if (process.platform === 'win32') {
-            // logger.info(`Redis 建立连接失败：${data}`)
-            return await this.LevelDB();
-        }
-        this.RunCmd = 'redis-server --save 900 1 --save 300 10 --daemonize yes' + (await this.aarch64());
-        logger.info('正在尝试启动 Redis...');
-        try {
-            await this.execSync(this.RunCmd);
-            /** 启动成功再次重试 */
-            const { status, data } = await this.connect(options);
-            if (status === 'ok') {
-                logger.info('Redis 连接成功');
-                return data;
-            }
-            logger.debug(`Redis 二次建立连接失败：${logger.red(data)}`);
-            return false;
-        }
-        catch (error) {
-            logger.debug(`Redis 启动失败：${logger.red(data)}`);
-            return await this.LevelDB();
-        }
-    }
-    /**
-     * 降级为 LevelDB
-     */
-    async LevelDB() {
-        try {
-            logger.debug('使用LevelDB代替Redis实现基础Api');
-            const redis = new RedisLevel();
-            return redis;
-        }
-        catch (error) {
-            logger.error('降级为 LevelDB 失败');
-            logger.error(error);
-            return false;
-        }
-    }
-    /**
-     * 连接 Redis 单例
-     */
-    async connect(options) {
-        const client = createClient(options);
-        try {
-            await client.connect();
-            return { status: 'ok', data: client };
-        }
-        catch (error) {
-            return { status: 'error', data: error };
-        }
-    }
-    /**
-     * 连接 Redis 集群
-     */
-    async connectCluster(rootNodes) {
-        const client = createCluster({ rootNodes });
-        try {
-            await client.connect();
-            return { status: 'ok', data: client };
-        }
-        catch (error) {
-            return { status: 'error', data: error };
-        }
-    }
-    /**
-     * 判断是否为 ARM64 并返回参数
-     */
-    async aarch64() {
-        try {
-            /** 判断arch */
-            const arch = await this.execSync('uname -m');
-            if (arch && arch.includes('aarch64')) {
-                /** 提取 Redis 版本 */
-                const version = await this.execSync('redis-server -v');
-                if (version) {
-                    /** 提取版本号 */
-                    const RedisVersion = version.match(/v=(\d)./);
-                    /** 如果>=6版本则忽略警告 */
-                    if (RedisVersion && Number(RedisVersion[1]) >= 6)
-                        return ' --ignore-warnings ARM64-COW-BUG';
-                }
-            }
-            return '';
-        }
-        catch {
-            return '';
-        }
-    }
-    execSync(cmd) {
-        return new Promise((resolve, reject) => {
-            exec(cmd, (error, stdout) => {
-                if (error)
-                    return reject(error);
-                resolve(stdout);
-            });
-        });
-    }
-}
-export const redis = await new Redis().start();