node-karin 1.15.5 → 1.16.1

package/dist/internal-DupfycKE.mjs

@@ -0,0 +1,597 @@
+import { t as __exportAll } from "./chunk-NzVPYdc1.mjs";
+import { f as sep } from "./file-dGy9of8-.mjs";
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import lodash from "lodash";
+import { EventEmitter } from "node:events";
+import os from "node:os";
+
+//#region src/utils/fs/path.ts
+/**
+* @description 根据文件后缀名从指定路径下读取符合要求的文件
+* @param path - 路径
+* @param ext - 后缀名、或后缀名列表
+* @param returnType - 返回类型 `name:文件名` `rel:相对路径` `abs:绝对路径`
+* @example
+* ```ts
+* filesByExt('./plugins/karin-plugin-test', '.js')
+* // -> ['1.js', '2.js']
+* filesByExt('./plugins', ['.js', '.ts'], 'name')
+* // -> ['1.js', '2.js', '3.ts']
+* filesByExt('./plugins', '.js', 'rel')
+* // -> ['plugins/1.js', 'plugins/2.js']
+* filesByExt('./plugins', '.js', 'abs')
+* // -> ['C:/Users/karin/plugins/1.js', 'C:/Users/karin/plugins/2.js']
+* ```
+*/
+const filesByExt = (filePath, ext, returnType = "name") => {
+	if (!fs.existsSync(filePath) || !fs.statSync(filePath).isDirectory()) return [];
+	const files = fs.readdirSync(filePath, { withFileTypes: true });
+	const list = [];
+	if (!Array.isArray(ext)) ext = [ext];
+	const allFiles = (dir, entry) => {
+		/** 如果是目录则递归查找 */
+		if (entry.isDirectory()) {
+			const subFiles = filesByExt(path.join(dir, entry.name), ext, returnType);
+			list.push(...subFiles);
+		} else if (ext.includes(path.extname(entry.name))) {
+			/** 如果是文件则添加到列表 */
+			if (returnType === "name") list.push(entry.name);
+			else if (returnType === "rel") {
+				const file = path.resolve(dir, entry.name);
+				list.push(path.relative(process.cwd(), file));
+			} else if (returnType === "abs") list.push(formatPath(path.resolve(dir, entry.name)));
+		}
+	};
+	files.forEach((entry) => allFiles(filePath, entry));
+	return list;
+};
+/**
+* @description 分割路径为文件夹路径和文件名
+* @param filePath - 路径
+* @returns - 文件夹路径和文件名
+* @example
+* ```ts
+* splitPath('C:/Users/admin/1.txt')
+* // -> { dirname: 'C:/Users/admin', basename: '1.txt' }
+* ```
+*/
+const splitPath = (filePath) => {
+	return {
+		dirname: path.dirname(filePath).replace(sep, ""),
+		basename: path.basename(filePath)
+	};
+};
+/**
+* @description 去掉相对路径的前缀和后缀
+* @param filePath - 相对路径路径
+* @example
+* ```ts
+* getRelPath('./plugins/karin-plugin-example/index.ts')
+* // -> 'plugins/karin-plugin-example/index.ts'
+* ```
+*/
+const getRelPath = (filePath) => filePath.replace(/\\+/g, "/").replace(/\.+\/+|\/+$/g, "");
+/**
+* 根据传入的 import.meta.url 计算相对于项目根目录的路径，返回需要的 '../' 层级。
+* @param url - import.meta.url
+* @returns 相对路径的层级数量，用 '../' 表示
+* @example
+* ```ts
+* // 在 plugins/karin-plugin-example/index.ts 中使用
+* urlToPath(import.meta.url)
+* // -> '../../'
+* ```
+*/
+const urlToPath = (url) => {
+	const filePath = fileURLToPath(url);
+	/** 相对路径的层级数量 */
+	const upLevelsCount = path.relative(path.dirname(filePath), process.cwd()).split(path.sep).length;
+	return lodash.repeat("../", upLevelsCount);
+};
+/**
+* @description 检查目标路径是否处于根路径下
+* @param root 根路径
+* @param target 目标路径
+* @param isAbs 是否将传入的路径转为绝对路径
+* @returns 返回布尔值
+*/
+const isSubPath = (root, target, isAbs = true) => {
+	if (isAbs) {
+		root = path.resolve(root);
+		target = path.resolve(target);
+	}
+	/** 相对路径 */
+	const relative = path.relative(root, target);
+	/** 检查是否以 `..` 开头或是否为空路径 如果是则代表目标路径不处于根路径下 */
+	return relative && !relative.startsWith("..") && !path.isAbsolute(relative);
+};
+/**
+* @description 将路径统一格式
+* - 绝对路径
+* - 统一分隔符`/`
+* @param filePath - 路径
+* @returns 统一格式后的路径
+*/
+const formatPath = (filePath) => {
+	return path.resolve(filePath).replace(/\\/g, "/");
+};
+/**
+* @description 比较两个路径是否相同
+* @param path1 - 第一个路径
+* @param path2 - 第二个路径
+* @returns 是否相同
+* @example
+* ```ts
+* isPathEqual('C:\\Users\\admin', 'C:/Users/admin')
+* // -> true
+* isPathEqual('./folder', 'folder')
+* // -> true
+* ```
+*/
+const isPathEqual = (path1, path2) => {
+	/** 先直接判断 */
+	if (path1 === path2) return true;
+	/** 格式化后第二次比较 */
+	path1 = formatPath(path1);
+	path2 = formatPath(path2);
+	if (path1 === path2) return true;
+	/** 判断是否为windows */
+	if (process.platform === "win32") return path1.toLowerCase() === path2.toLowerCase();
+	return false;
+};
+
+//#endregion
+//#region src/plugin/system/cache.ts
+/** 缓存 */
+const cache = {
+	index: {},
+	accept: [],
+	command: [],
+	task: [],
+	button: [],
+	handler: {},
+	missing: /* @__PURE__ */ new Map(),
+	watcher: /* @__PURE__ */ new Map(),
+	count: {
+		accept: 0,
+		command: 0,
+		task: 0,
+		button: 0,
+		handler: {
+			key: 0,
+			fnc: 0
+		}
+	},
+	static: []
+};
+
+//#endregion
+//#region src/utils/fs/static.ts
+/**
+* @description 传入一个文件路径，检查是否是静态资源中的文件
+* @param filePath 文件路径
+* @returns 是否是静态资源中的文件
+*/
+const isPublic = (filePath) => {
+	try {
+		for (const item of cache.static) if (isSubPath(item, filePath)) return true;
+		return false;
+	} catch (error) {
+		logger.error(error);
+		return false;
+	}
+};
+
+//#endregion
+//#region src/utils/fs/key.ts
+var key_exports = /* @__PURE__ */ __exportAll({
+	BOT_CONNECT: () => BOT_CONNECT,
+	BOT_DISCONNECT: () => BOT_DISCONNECT,
+	EVENT_COUNT: () => EVENT_COUNT,
+	FILE_CHANGE: () => FILE_CHANGE,
+	RECV_MSG: () => RECV_MSG,
+	SEND_MSG: () => SEND_MSG,
+	WS_CLOSE: () => WS_CLOSE,
+	WS_CLOSE_ONEBOT: () => WS_CLOSE_ONEBOT,
+	WS_CLOSE_PUPPETEER: () => WS_CLOSE_PUPPETEER,
+	WS_CLOSE_SANDBOX: () => WS_CLOSE_SANDBOX,
+	WS_CONNECTION: () => WS_CONNECTION,
+	WS_CONNECTION_ONEBOT: () => WS_CONNECTION_ONEBOT,
+	WS_CONNECTION_PUPPETEER: () => WS_CONNECTION_PUPPETEER,
+	WS_CONNECTION_SANDBOX: () => WS_CONNECTION_SANDBOX,
+	WS_CONNECTION_TERMINAL: () => WS_CONNECTION_TERMINAL,
+	WS_SNAPKA: () => WS_SNAPKA
+});
+/** 收到消息 */
+const RECV_MSG = "karin:count:recv";
+/** 发送消息 */
+const SEND_MSG = "karin:count:send";
+/** 事件调用 */
+const EVENT_COUNT = "karin:count:fnc";
+/** 文件变动 */
+const FILE_CHANGE = "karin:file:change";
+/** 传递ws连接 */
+const WS_CONNECTION = "ws:connection";
+/** 传递onebot ws连接 */
+const WS_CONNECTION_ONEBOT = "ws:connection:onebot";
+/** 传递puppeteer ws连接 */
+const WS_CONNECTION_PUPPETEER = "ws:connection:puppeteer";
+/** 传递sandbox ws连接 */
+const WS_CONNECTION_SANDBOX = "ws:connection:sandbox";
+/** 传递虚拟终端 ws连接 */
+const WS_CONNECTION_TERMINAL = "ws:connection:terminal";
+/** 传递ws关闭 */
+const WS_CLOSE = "ws:close";
+/** 传递onebot ws关闭 */
+const WS_CLOSE_ONEBOT = "ws:close:onebot";
+/** 传递puppeteer ws关闭 */
+const WS_CLOSE_PUPPETEER = "ws:close:puppeteer";
+/** 传递sandbox ws关闭 */
+const WS_CLOSE_SANDBOX = "ws:close:sandbox";
+/** 传递 snapka ws连接 */
+const WS_SNAPKA = "ws:connection:snapka";
+/** Bot连接成功 */
+const BOT_CONNECT = "bot.connect";
+/** Bot连接断开 */
+const BOT_DISCONNECT = "bot.disconnect";
+
+//#endregion
+//#region src/core/internal/listeners.ts
+/** 类型化事件监听器 */
+var TypedListeners = class extends EventEmitter {
+	/**
+	* 注册事件监听器
+	* @param event 事件名称
+	* @param listener 监听器函数
+	*/
+	on(event, listener) {
+		return super.on(event, listener);
+	}
+	/**
+	* 注册一次性事件监听器
+	* @param event 事件名称
+	* @param listener 监听器函数
+	*/
+	once(event, listener) {
+		return super.once(event, listener);
+	}
+	/**
+	* 移除事件监听器
+	* @param event 事件名称
+	* @param listener 监听器函数
+	*/
+	off(event, listener) {
+		return super.off(event, listener);
+	}
+	/**
+	* 触发事件
+	* @param event 事件名称
+	* @param args 事件参数
+	*/
+	emit(event, ...args) {
+		return super.emit(event, ...args);
+	}
+	/**
+	* 获取事件监听器列表
+	* @param event 事件名称
+	*/
+	listeners(event) {
+		return super.listeners(event);
+	}
+	/**
+	* 移除所有事件监听器
+	* @param event 事件名称
+	* @returns this
+	*/
+	removeAllListeners(event) {
+		super.removeAllListeners(event);
+		return this;
+	}
+	/**
+	* 设置最大监听器数量
+	* @param n 最大监听器数量
+	* @returns this
+	*/
+	setMaxListeners(n) {
+		super.setMaxListeners(n);
+		return this;
+	}
+	/**
+	* 获取最大监听器数量
+	* @returns 最大监听器数量
+	*/
+	getMaxListeners() {
+		return super.getMaxListeners();
+	}
+	/**
+	* 添加事件监听器
+	* @param event 事件名称
+	* @param listener 监听器函数
+	*/
+	addListener(event, listener) {
+		return super.addListener(event, listener);
+	}
+	/**
+	* 获取事件监听器数量
+	* @param event 事件名称
+	* @returns 监听器数量
+	*/
+	listenerCount(event) {
+		return super.listenerCount(event);
+	}
+	/**
+	* 返回已注册的事件名称数组
+	* @param event 事件名称
+	* @returns 监听器数量
+	*/
+	eventNames() {
+		return super.eventNames();
+	}
+	/**
+	* 返回指定事件的原始监听器数组（包括一次性监听器）
+	* @param event 事件名称
+	* @returns 监听器数量
+	*/
+	rawListeners(event) {
+		return super.rawListeners(event);
+	}
+	/**
+	* 为指定事件添加监听器，但将其添加到监听器数组的开头
+	* @param event 事件名称
+	* @returns 监听器数量
+	*/
+	prependListener(event, listener) {
+		return super.prependListener(event, listener);
+	}
+	/**
+	*  为指定事件添加一次性监听器，并将其添加到监听器数组的开头
+	* @param event 事件名称
+	* @returns 监听器数量
+	*/
+	prependOnceListener(event, listener) {
+		return super.prependOnceListener(event, listener);
+	}
+	/**
+	* 移除事件监听器
+	* @param event 事件名称
+	* @param listener 监听器函数
+	*/
+	removeListener(event, listener) {
+		return super.removeListener(event, listener);
+	}
+};
+/**
+* @internal
+* @description 内部事件监听器
+*/
+const listeners = new TypedListeners();
+
+//#endregion
+//#region src/core/internal/error.ts
+/** 插件名称:缺失的依赖 */
+const missing = /* @__PURE__ */ new Map();
+/**
+* @description 插件载入错误
+* @param name 插件包名
+* @param file 报错的文件名称
+* @param error 错误信息
+*/
+const loaderPlugin = (name, file, error) => {
+	const pkg = /Cannot find package '(.+?)'/.exec(error)?.[1];
+	if (pkg) {
+		const key = `${name}.${pkg}`;
+		if (missing.has(key)) return;
+		missing.set(key, {
+			name,
+			file,
+			depend: pkg
+		});
+	} else {
+		logger.error(`载入插件错误：${logger.red(`${name}/${path.basename(file)}`)}`);
+		listeners.emit("error", error);
+	}
+};
+/**
+* @description 定时任务执行错误
+* @param name 插件包名
+* @param task 任务名称
+* @param error 错误信息
+*/
+const taskStart = (name, task, error) => {
+	logger.error(`[定时任务][${name}][${task}] 执行错误`);
+	listeners.emit("error", error);
+};
+/**
+* @description 打印插件载入错误
+*/
+const printMissing = () => {
+	try {
+		if (!missing.size) return;
+		const msg = ["\n-----依赖缺失----"];
+		for (const [, { name, file, depend }] of missing) msg.push(`[${name}][${path.basename(file)}] 缺少依赖：${logger.red(depend)}`);
+		msg.push("-------------------");
+		const one = missing.values().next().value;
+		msg.push(...[
+			"温馨提示:",
+			`1. 如果是新安装的插件，请尝试执行 ${logger.red("pnpm install -P")} 自动安装依赖`,
+			`2. 如果执行第一步无效，请尝试执行 ${logger.red("pnpm imstall 依赖名称 -w")} 手动安装依赖`,
+			`举例: ${logger.red(`pnpm add ${one.depend} -w`)}`,
+			logger.yellow("对于手动安装的依赖，如果对应插件未在使用，请进行及时卸载: pnpm rm 依赖名称")
+		]);
+		msg.push("-------------------");
+		logger.error(msg.join("\n"));
+	} finally {
+		missing.clear();
+	}
+};
+const errorHandler = {
+	/** 插件载入错误 */
+	loaderPlugin,
+	/** 定时任务执行错误 */
+	taskStart,
+	/** 打印插件载入错误 */
+	printMissing
+};
+
+//#endregion
+//#region src/core/internal/status_listener.ts
+var StatusHelper = class {
+	psCpuUsage = process.cpuUsage();
+	psCurrentTime = process.hrtime();
+	cpuTimes = os.cpus().map((cpu) => cpu.times);
+	replaceNaN(value) {
+		return isNaN(value) ? 0 : value;
+	}
+	sysCpuInfo() {
+		const currentTimes = os.cpus().map((cpu) => cpu.times);
+		const { total, active } = currentTimes.map((times, index) => {
+			const prevTimes = this.cpuTimes[index];
+			const totalCurrent = times.user + times.nice + times.sys + times.idle + times.irq;
+			const totalPrev = prevTimes.user + prevTimes.nice + prevTimes.sys + prevTimes.idle + prevTimes.irq;
+			const activeCurrent = totalCurrent - times.idle;
+			const activePrev = totalPrev - prevTimes.idle;
+			return {
+				total: totalCurrent - totalPrev,
+				active: activeCurrent - activePrev
+			};
+		}).reduce((acc, cur) => ({
+			total: acc.total + cur.total,
+			active: acc.active + cur.active
+		}), {
+			total: 0,
+			active: 0
+		});
+		this.cpuTimes = currentTimes;
+		return {
+			usage: this.replaceNaN(active / total * 100).toFixed(2),
+			model: os.cpus()[0].model,
+			speed: os.cpus()[0].speed,
+			core: os.cpus().length
+		};
+	}
+	sysMemoryUsage() {
+		const { total, free } = {
+			total: os.totalmem(),
+			free: os.freemem()
+		};
+		return ((total - free) / 1024 / 1024).toFixed(2);
+	}
+	karinUsage() {
+		const mem = process.memoryUsage();
+		const numCpus = os.cpus().length;
+		const usageDiff = process.cpuUsage(this.psCpuUsage);
+		const endTime = process.hrtime(this.psCurrentTime);
+		this.psCpuUsage = process.cpuUsage();
+		this.psCurrentTime = process.hrtime();
+		const normPercent = (usageDiff.user + usageDiff.system) / 1e3 / (endTime[0] * 1e3 + endTime[1] / 1e6) / numCpus * 100;
+		return {
+			cpu: this.replaceNaN(normPercent).toFixed(2),
+			memory: ((mem.heapTotal + mem.external + mem.arrayBuffers) / 1024 / 1024).toFixed(2)
+		};
+	}
+	/**
+	* 获取系统状态信息
+	*/
+	systemStatus() {
+		const karinUsage = this.karinUsage();
+		const sysCpuInfo = this.sysCpuInfo();
+		const memUsage = process.memoryUsage();
+		let userInfo;
+		try {
+			userInfo = os.userInfo();
+		} catch (e) {
+			userInfo = void 0;
+		}
+		let loadavg;
+		try {
+			loadavg = os.loadavg();
+		} catch (e) {
+			loadavg = void 0;
+		}
+		return {
+			cpu: {
+				core: sysCpuInfo.core,
+				model: sysCpuInfo.model,
+				speed: (sysCpuInfo.speed / 1e3).toFixed(2),
+				usage: {
+					system: sysCpuInfo.usage,
+					karin: karinUsage.cpu
+				}
+			},
+			memory: {
+				total: (os.totalmem() / 1024 / 1024).toFixed(2),
+				usage: {
+					system: this.sysMemoryUsage(),
+					karin: karinUsage.memory
+				},
+				details: {
+					rss: (memUsage.rss / 1024 / 1024).toFixed(2),
+					heapTotal: (memUsage.heapTotal / 1024 / 1024).toFixed(2),
+					heapUsed: (memUsage.heapUsed / 1024 / 1024).toFixed(2),
+					external: (memUsage.external / 1024 / 1024).toFixed(2),
+					arrayBuffers: (memUsage.arrayBuffers / 1024 / 1024).toFixed(2)
+				}
+			},
+			system: {
+				arch: `${os.platform()} ${os.arch()}`,
+				hostname: os.hostname(),
+				osName: os.type(),
+				osVersion: os.release(),
+				platform: os.platform(),
+				uptime: os.uptime(),
+				loadavg,
+				tmpdir: os.tmpdir(),
+				homedir: os.homedir()
+			},
+			process: {
+				nodeVersion: process.version,
+				pid: process.pid,
+				uptime: process.uptime(),
+				execPath: process.execPath,
+				argv: process.argv,
+				env: {
+					nodeEnv: process.env.NODE_ENV,
+					timezone: process.env.TZ
+				},
+				user: userInfo ? {
+					username: userInfo.username,
+					homedir: userInfo.homedir,
+					shell: userInfo.shell
+				} : void 0
+			},
+			network: { interfaces: os.networkInterfaces() }
+		};
+	}
+};
+var StatusHelperSubscription = class extends EventEmitter {
+	statusHelper;
+	interval = null;
+	constructor(time = 3e3) {
+		super();
+		this.statusHelper = new StatusHelper();
+		this.on("newListener", (event) => {
+			if (event === "statusUpdate" && this.listenerCount("statusUpdate") === 0) this.startInterval(time);
+		});
+		this.on("removeListener", (event) => {
+			if (event === "statusUpdate" && this.listenerCount("statusUpdate") === 0) this.stopInterval();
+		});
+	}
+	startInterval(time) {
+		this.interval ??= setInterval(() => {
+			const status = this.statusHelper.systemStatus();
+			this.emit("statusUpdate", status);
+		}, time);
+	}
+	stopInterval() {
+		if (this.interval) {
+			clearInterval(this.interval);
+			this.interval = null;
+		}
+	}
+};
+const statusListener = new StatusHelperSubscription();
+
+//#endregion
+export { filesByExt as C, isSubPath as D, isPathEqual as E, splitPath as O, cache as S, getRelPath as T, WS_CONNECTION_SANDBOX as _, BOT_DISCONNECT as a, key_exports as b, RECV_MSG as c, WS_CLOSE_ONEBOT as d, WS_CLOSE_PUPPETEER as f, WS_CONNECTION_PUPPETEER as g, WS_CONNECTION_ONEBOT as h, BOT_CONNECT as i, urlToPath as k, SEND_MSG as l, WS_CONNECTION as m, errorHandler as n, EVENT_COUNT as o, WS_CLOSE_SANDBOX as p, listeners as r, FILE_CHANGE as s, statusListener as t, WS_CLOSE as u, WS_CONNECTION_TERMINAL as v, formatPath as w, isPublic as x, WS_SNAPKA as y };