node-karin 0.10.0 → 0.10.1

package/config/defSet/group.yaml

@@ -1,4 +1,4 @@
-# 默认配置
+# 全局默认配置
 default:
   # 群聊中所有消息冷却时间，单位秒,0则无限制
   GroupCD: 0
@@ -9,7 +9,45 @@ default:
 
   # 机器人前缀 设置后前缀+指令触发机器人
   alias:
-    - karin
+    - k
+
+  # 白名单插件、功能，只有在白名单中的插件、功能才会响应
+  enable: []
+
+  # 黑名单插件、功能，黑名单中的插件、功能不会响应
+  disable: []
+
+# 单个Bot默认配置
+Bot.self_id:
+  # 群聊中所有消息冷却时间，单位秒,0则无限制
+  GroupCD: 0
+  # 群聊中 每个人的消息冷却时间，单位秒，0则无限制。注意，开启后所有消息都会进CD，无论是否触发插件。
+  GroupUserCD: 1
+  # 机器人响应模式，0-所有 1-仅@机器人 2-仅回应主人 3-仅回应前缀 4-前缀或@机器人 5-主人无前缀，群员前缀或@机器人
+  mode: 0
+
+  # 机器人前缀 设置后前缀+指令触发机器人
+  alias:
+    - k
+
+  # 白名单插件、功能，只有在白名单中的插件、功能才会响应
+  enable: []
+
+  # 黑名单插件、功能，黑名单中的插件、功能不会响应
+  disable: []
+
+# 单个Bot单个群配置
+Bot.self_id.group_id:
+  # 群聊中所有消息冷却时间，单位秒,0则无限制
+  GroupCD: 0
+  # 群聊中 每个人的消息冷却时间，单位秒，0则无限制。注意，开启后所有消息都会进CD，无论是否触发插件。
+  GroupUserCD: 1
+  # 机器人响应模式，0-所有 1-仅@机器人 2-仅回应主人 3-仅回应前缀 4-前缀或@机器人 5-主人无前缀，群员前缀或@机器人
+  mode: 0
+
+  # 机器人前缀 设置后前缀+指令触发机器人
+  alias:
+    - k
 
   # 白名单插件、功能，只有在白名单中的插件、功能才会响应
   enable: []

package/lib/adapter/onebot/11/index.js

@@ -1,6 +1,6 @@
 import WebSocket from 'ws';
 import { randomUUID } from 'crypto';
-import { listener } from '../../../core/listener.js';
+import { listener } from '../../../core/listener/listener.js';
 import { common, config, logger, segment } from '../../../utils/index.js';
 import { OB11Event } from './event.js';
 import { AdapterConvertKarin, KarinConvertAdapter } from './convert.js';

package/lib/cli/init.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { KarinInit } from '../utils/init.js'
+import { KarinInit } from '../utils/core/init.js'
 /**
  * 休眠函数
  * @param ms 毫秒

package/lib/cli/karin.js

@@ -6,7 +6,7 @@ import axios from 'axios'
 import { fileURLToPath } from 'url'
 import { program } from 'commander'
 import { exec as execCmd, spawn } from 'child_process'
-import { KarinInit } from '../utils/init.js'
+import { KarinInit } from '../utils/core/init.js'
 class KarinCli {
   child
   filename

package/lib/core/index.d.ts

@@ -1,10 +1,10 @@
-export * from './dir.js';
-export * from './init.js';
-export * from './karin.js';
-export * from './listener.js';
-export * from './plugin.js';
-export * from './plugin.app.js';
-export * from './plugin.loader.js';
-export * from './process.js';
-export * from './server.js';
+export * from './init/dir.js';
+export * from './init/init.js';
+export * from './karin/karin.js';
+export * from './listener/listener.js';
+export * from './plugin/base.js';
+export * from './plugin/app.js';
+export * from './plugin/loader.js';
+export * from './process/process.js';
+export * from './server/server.js';
 import '../adapter/input/index.js';

package/lib/core/index.js

@@ -1,10 +1,10 @@
-export * from './dir.js'
-export * from './init.js'
-export * from './karin.js'
-export * from './listener.js'
-export * from './plugin.js'
-export * from './plugin.app.js'
-export * from './plugin.loader.js'
-export * from './process.js'
-export * from './server.js'
+export * from './init/dir.js'
+export * from './init/init.js'
+export * from './karin/karin.js'
+export * from './listener/listener.js'
+export * from './plugin/base.js'
+export * from './plugin/app.js'
+export * from './plugin/loader.js'
+export * from './process/process.js'
+export * from './server/server.js'
 import '../adapter/input/index.js'

package/lib/core/init/dir.js

@@ -0,0 +1,7 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+const filename = fileURLToPath(import.meta.url);
+/**
+ * - 获取当前npm包的根目录
+ */
+export const karinDir = path.resolve(filename, '../../../../').replace(/\\/g, '/').replace(/\/$/, '');

package/lib/core/init/init.js

@@ -0,0 +1,46 @@
+import { logger } from '../../utils/index.js';
+/**
+ * 启动日志
+ */
+logger.mark('Karin 启动中...');
+logger.mark('https://github.com/KarinJS/Karin');
+/**
+ * 设置标题
+ */
+process.title = 'Karin';
+/**
+ * 设置时区
+ */
+process.env.TZ = 'Asia/Shanghai';
+const init = () => {
+    if (!process.env.karin_app_lang)
+        process.env.karin_app_lang = 'js';
+    if (!process.env.karin_app_mode)
+        process.env.karin_app_mode = 'prod';
+    if (!process.env.karin_app_runner)
+        process.env.karin_app_runner = 'node';
+    if (!process.env.karin_app_start_count)
+        process.env.karin_app_start_count = '0';
+    /** 正常启动 */
+    if (process.env.karin_app_runner === 'node' && process.env.karin_app_lang === 'js' && process.env.karin_app_mode === 'prod') {
+        logger.debug('当前为 JavaScript 生产模式');
+        return;
+    }
+    /** pm2 */
+    if (process.env.karin_app_runner === 'pm2') {
+        logger.info('当前为 PM2 模式');
+        return;
+    }
+    /** js开发模式 */
+    if (process.env.karin_app_lang === 'js' && process.env.karin_app_mode === 'dev') {
+        logger.info('当前为 JavaScript 开发模式');
+        return;
+    }
+    /** ts开发模式 */
+    if (process.env.karin_app_lang === 'ts' && process.env.karin_app_mode === 'dev') {
+        logger.info('当前为 TypeScript 开发模式');
+        return;
+    }
+    logger.error('未知的启动模式');
+};
+init();

package/lib/core/{karin.d.ts → karin/karin.d.ts}

@@ -1,4 +1,4 @@
-import { Contact, PluginApps, KarinElement, KarinMessage, KarinRenderType, PermissionType, RenderResult, NoticeListenEvent, RequestListenEvent, KarinNoticeType, KarinRequestType } from '../types/index.js';
+import { Contact, PluginApps, KarinElement, KarinMessage, KarinRenderType, PermissionType, RenderResult, NoticeListenEvent, RequestListenEvent, KarinNoticeType, KarinRequestType } from '../../types/index.js';
 type FncFunction = (e: KarinMessage) => Promise<boolean>;
 type FncElement = string | KarinElement | Array<KarinElement>;
 export interface OptionsCommand {

package/lib/core/karin/karin.js

@@ -0,0 +1,194 @@
+import { server } from '../server/server.js';
+import { stateArr } from '../plugin/base.js';
+import PluginApp from '../plugin/app.js';
+import { common } from '../../utils/index.js';
+import { listener } from '../listener/listener.js';
+import onebot11 from '../../adapter/onebot/11/index.js';
+import { render, RenderServer } from '../../render/index.js';
+export class Karin {
+    start;
+    constructor() {
+        this.start = false;
+        this.run();
+    }
+    /**
+     * - 快速构建命令
+     * @param reg - 正则表达式
+     * @param second - 函数或者字符串或者KarinElement、KarinElement数组
+     * @param options - 选项
+     * @returns - 返回插件对象
+     */
+    command(reg, second, options = {}) {
+        reg = typeof reg === 'string' ? new RegExp(reg) : reg;
+        const fnc = typeof second === 'function'
+            ? second
+            : async (e) => {
+                const element = typeof second === 'number' ? String(second) : second;
+                if ('delay' in options && options.delay)
+                    await common.sleep(options.delay);
+                await e.reply(element, {
+                    at: ('at' in options && options.at) || false,
+                    reply: ('reply' in options && options.reply) || false,
+                    recallMsg: ('recallMsg' in options && Number(options.recallMsg)) || 0,
+                });
+                return !('stop' in options && !options.stop);
+            };
+        const data = {
+            name: options.name || 'function',
+            priority: options.priority,
+            rule: [
+                {
+                    reg,
+                    fnc,
+                    permission: options.permission || 'all',
+                    log: options.log ?? true,
+                },
+            ],
+        };
+        return PluginApp(data);
+    }
+    /**
+     * - 构建定时任务
+     * @param name - 任务名称
+     * @param cron - cron表达式
+     * @param fnc - 执行函数
+     * @param options - 选项
+     */
+    task(name, cron, fnc, options) {
+        if (!name)
+            throw new Error('[task]: 缺少参数[name]');
+        if (!cron)
+            throw new Error('[task]: 缺少参数[cron]');
+        if (!fnc)
+            throw new Error('[task]: 缺少参数[fnc]');
+        const data = {
+            name: options?.name || 'task',
+            priority: options?.priority,
+            task: [
+                {
+                    name,
+                    cron,
+                    fnc,
+                    log: options?.log ?? true,
+                },
+            ],
+        };
+        return PluginApp(data);
+    }
+    /**
+     * - 构建handler
+     * @param key - 事件key
+     * @param fnc - 函数实现
+     * @param options - 选项
+     */
+    handler(key, fnc, options) {
+        if (!key)
+            throw new Error('[handler]: 缺少参数[key]');
+        if (!fnc)
+            throw new Error('[handler]: 缺少参数[fnc]');
+        const priority = options?.priority || 10000;
+        const data = {
+            name: options?.name || 'handler',
+            priority,
+            handler: [
+                {
+                    key,
+                    fnc,
+                    priority,
+                },
+            ],
+        };
+        return PluginApp(data);
+    }
+    /**
+     * 构建contact
+     * @param peer - 群号或者id
+     * @param isGroup - 是否是群聊
+     * @param sub_peer - 子id
+     */
+    contact(peer, isGroup = true, sub_peer) {
+        if (isGroup) {
+            return {
+                scene: "group" /* Scene.Group */,
+                peer,
+                sub_peer: sub_peer || '',
+            };
+        }
+        return {
+            scene: "friend" /* Scene.Private */,
+            peer,
+            sub_peer: sub_peer || '',
+        };
+    }
+    /**
+     * - 渲染
+     * @param data - 渲染参数
+     * @param multiPage - 分片高度
+     * @returns - 返回图片base64或数组
+     */
+    render(data, multiPage) {
+        if (typeof data === 'string') {
+            /** 分片 */
+            if (typeof multiPage === 'number' || multiPage === true) {
+                return render.renderMultiHtml(data, multiPage);
+            }
+            /** 快速渲染 */
+            return render.renderHtml(data);
+        }
+        /** 正常渲染 */
+        return render.render(data);
+    }
+    /**
+     * 上下文
+     * @param e - 消息事件
+     * @param options - 上下文选项
+     */
+    async ctx(e, options) {
+        const time = options?.time || 120;
+        const userId = options?.userId || e.user_id;
+        const key = e.group_id ? `${e.group_id}.${userId}` : userId;
+        stateArr[key] = { type: 'ctx' };
+        // 返回promise 设置超时时间
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                if (stateArr[key]) {
+                    delete stateArr[key];
+                    if (options?.reply)
+                        e.reply(options.replyMsg || '操作超时已取消');
+                    reject(new Error('操作超时已取消'));
+                    return true;
+                }
+            }, time * 1000);
+            listener.once(`ctx:${key}`, (e) => resolve(e));
+        });
+    }
+    /**
+     * accept
+     * @param event - 监听事件
+     * @param fnc - 实现函数
+     */
+    accept(event, fnc, options) {
+        const data = {
+            name: options?.name || 'accept',
+            priority: options?.priority,
+            event,
+            accept: fnc,
+            log: options?.log,
+        };
+        return PluginApp(data);
+    }
+    /**
+     * - 启动
+     */
+    run() {
+        if (this.start)
+            return;
+        this.start = true;
+        server.init();
+        listener.emit('load.plugin');
+        listener.emit('adapter', RenderServer);
+        listener.emit('adapter', onebot11);
+    }
+}
+export const karin = new Karin();
+export default karin;

package/lib/core/{listener.d.ts → listener/listener.d.ts}

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'events';
-import { KarinAdapter, Contact, KarinElement } from '../types/index.js';
+import { KarinAdapter, Contact, KarinElement } from '../../types/index.js';
 /**
  * 监听器管理
  */

package/lib/core/listener/listener.js

@@ -0,0 +1,213 @@
+import { level } from '../../db/index.js';
+import { EventEmitter } from 'events';
+import { pluginLoader } from '../plugin/loader.js';
+import { common, logger, config, segment } from '../../utils/index.js';
+import { MessageHandler, NoticeHandler, RequestHandler } from '../../event/index.js';
+/**
+ * 监听器管理
+ */
+class Listeners extends EventEmitter {
+    /**
+     * Bot索引
+     * @type - Bot索引
+     */
+    index;
+    /**
+     * 框架名称
+     */
+    name;
+    list;
+    adapter;
+    constructor() {
+        super();
+        this.index = 0;
+        this.name = 'Karin';
+        this.list = [];
+        this.adapter = [];
+        this.on('error', data => logger.error(data));
+        this.on('load.plugin', () => pluginLoader.load());
+        this.on('adapter', data => {
+            let path = data.path || '无';
+            if (path && data.type !== 'grpc')
+                path = `ws://127.0.0.1:${config.Server.http.port}${data.path}`;
+            path = logger.green(path);
+            logger.info(`[适配器][注册][${data.type}]: ` + path);
+            this.addAdapter(data);
+        });
+        this.on('message', data => new MessageHandler(data));
+        this.on('notice', data => new NoticeHandler(data));
+        this.on('request', data => new RequestHandler(data));
+    }
+    /**
+     * 注册Bot 返回索引id
+     */
+    addBot(data) {
+        this.index++;
+        const index = this.index;
+        if (!data.bot) {
+            logger.error('[Bot管理][注册] 注册失败: Bot实例不能为空', JSON.stringify(data));
+            return false;
+        }
+        this.list.push({ index, type: data.type, bot: data.bot });
+        logger.info(`[机器人][注册][${data.type}] ` + logger.green(`[account:${data.bot.account.uid || data.bot.account.uin}(${data.bot.account.name})]`));
+        this.#online(data.bot.account.uid || data.bot.account.uin);
+        logger.debug('注册', this.list);
+        return index;
+    }
+    /**
+   * 发送上线通知
+   */
+    async #online(uid) {
+        /** 重启 */
+        const key = `karin:restart:${uid}`;
+        const options = await level.get(key);
+        if (!options)
+            return;
+        const { id, contact, time, message_id } = options;
+        /** 重启花费时间 保留2位小数 */
+        const restartTime = ((Date.now() - time) / 1000).toFixed(2);
+        /** 超过2分钟不发 */
+        if (Number(restartTime) > 120) {
+            await level.del(key);
+            return false;
+        }
+        const element = [
+            segment.reply(message_id),
+            segment.text(`Karin 重启成功：${restartTime}秒`),
+        ];
+        await this.sendMsg(id, contact, element);
+        await level.del(key);
+        return true;
+    }
+    /**
+     * 卸载Bot
+     * @param index - Bot的索引id
+     */
+    delBot(index) {
+        this.list = this.list.filter(item => item.index !== index);
+        logger.debug('[机器人][卸载] ', this.list);
+    }
+    /**
+     * 通过Bot uid 获取Bot
+     * @param uid - Bot的uid 未传入则返回第一个Bot
+     */
+    getBot(uid = '') {
+        uid = String(uid);
+        if (this.list.length === 0) {
+            logger.error('[Bot管理][UID] 当前Bot列表为空');
+            return undefined;
+        }
+        if (!uid)
+            return this.list[0].bot;
+        const index = this.list.findIndex(item => String(item.bot.account.uid) === uid);
+        if (index === -1) {
+            logger.error('[Bot管理][UID] 无法找到对应的 Bot 实例');
+            return undefined;
+        }
+        return this.list[index].bot;
+    }
+    /**
+     * 根据索引获取Bot
+     * @param index - Bot的索引id
+     */
+    getBotByIndex(index) {
+        index = this.list.findIndex(item => item.index === index);
+        if (index === -1) {
+            throw new Error('[Bot管理][索引] 无法找到对应的 Bot 实例');
+        }
+        return this.list[index].bot;
+    }
+    /**
+     * 获取当前已注册Bot数量
+     */
+    getBotCount() {
+        return this.list.length;
+    }
+    /**
+     * 获取所有Bot列表
+     * @param isIndex - 是否返回包含的索引列表 默认返回Bot实例列表
+     */
+    getBotAll(isIndex = false) {
+        if (isIndex)
+            return this.list;
+        return this.list.map(item => item.bot);
+    }
+    /**
+     * 注册适配器
+     * @param data - 适配器信息
+     * @param data.type - 适配器类型
+     * @param data.adapter - 适配器实例
+     * @param data.path - 适配器路径
+     */
+    addAdapter(data) {
+        const adapter = { type: data.type, adapter: data.adapter, path: '' };
+        if (data.path)
+            adapter.path = data.path;
+        this.adapter.push(adapter);
+    }
+    /**
+     * 通过path获取适配器 仅适用于反向WS适配器
+     * @param path - 适配器路径
+     */
+    getAdapter(path = '') {
+        const index = this.adapter.findIndex(item => item?.path === path);
+        if (index === -1) {
+            logger.error('[适配器管理] 无法找到对应的适配器实例');
+            return undefined;
+        }
+        return this.adapter[index].adapter;
+    }
+    /**
+     * 获取适配器列表
+     * @param isType - 是否返回包含的类型列表 默认返回适配器实例列表
+     */
+    getAdapterAll(isType = false) {
+        if (isType)
+            return this.adapter;
+        return this.adapter.map(item => item.adapter);
+    }
+    /**
+     * 发送主动消息
+     * @param uid - Bot的uid
+     * @param contact - 目标信息
+     * @param elements - 消息内容
+     * @param options - 消息选项
+     * @param options.recallMsg - 发送成功后撤回消息时间
+     * @param options.retry_count - 重试次数
+     */
+    async sendMsg(uid, contact, elements, options = { recallMsg: 0, retry_count: 1 }) {
+        const bot = this.getBot(uid);
+        if (!bot)
+            throw new Error('发送消息失败: 未找到对应Bot实例');
+        const { recallMsg, retry_count } = options;
+        /** 标准化 */
+        const NewElements = common.makeMessage(elements);
+        /** 结果 */
+        let result = {};
+        const reply_log = common.makeMessageLog(NewElements);
+        const self_id = bot.account.uid || bot.account.uin;
+        if (contact.scene === 'group') {
+            logger.bot('info', self_id, `${logger.green('Send Proactive Group')} ${contact.peer}: ${reply_log}`);
+        }
+        else {
+            logger.bot('info', self_id, `${logger.green('Send Proactive private')} ${contact.peer}: ${reply_log}`);
+        }
+        try {
+            this.emit('karin:count:send', 1);
+            /** 取结果 */
+            result = await bot.SendMessage(contact, NewElements, retry_count);
+            logger.bot('debug', self_id, `主动消息结果:${JSON.stringify(result, null, 2)}`);
+        }
+        catch (error) {
+            logger.bot('error', self_id, `主动消息发送失败:${reply_log}`);
+            logger.bot('error', self_id, error);
+        }
+        /** 快速撤回 */
+        if (recallMsg && bot.RecallMessage && recallMsg > 0 && result?.message_id) {
+            setTimeout(() => bot.RecallMessage(contact, result.message_id), recallMsg * 1000);
+        }
+        return result;
+    }
+}
+export const listener = new Listeners();
+export const Bot = listener;

package/lib/core/{plugin.app.d.ts → plugin/app.d.ts}

@@ -1,4 +1,4 @@
-import { dirName, fileName, PluginApps } from '../types/index.js';
+import { dirName, fileName, PluginApps } from '../../types/index.js';
 export interface PluginAppType {
     file?: {
         dir?: dirName;

package/lib/core/plugin/app.js

@@ -0,0 +1,19 @@
+export default function PluginApp(options) {
+    return {
+        file: {
+            dir: options?.file?.dir || '',
+            name: options?.file?.name || '',
+            type: options?.file?.type || 'function',
+            Fnc: options?.file?.fnc || '',
+        },
+        name: options.name || '',
+        event: options.event || "message" /* EventType.Message */,
+        priority: options.priority || 10000,
+        accept: options.accept ?? false,
+        log: options.log ?? true,
+        rule: options.rule || [],
+        task: options.task || [],
+        handler: options.handler || [],
+        button: options.button || [],
+    };
+}

package/lib/core/{plugin.d.ts → plugin/base.d.ts}

@@ -1,4 +1,4 @@
-import { PluginType, KarinElement, NodeElement, stateArrType, KarinNoticeType, KarinRequestType, ReplyReturn, EType } from '../types/index.js';
+import { PluginType, KarinElement, NodeElement, stateArrType, KarinNoticeType, KarinRequestType, ReplyReturn, EType } from '../../types/index.js';
 /**
  * 插件基类
  */