mioki 0.1.2 → 0.2.1

package/dist/index.cjs

@@ -1,7 +1,1915 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 
-//#region src/index.ts
-function start() {}
+//#endregion
+let pino = require("pino");
+pino = __toESM(pino);
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let node_process = require("node:process");
+let mri = require("mri");
+mri = __toESM(mri);
+let node_crypto = require("node:crypto");
+node_crypto = __toESM(node_crypto);
+let lowdb = require("lowdb");
+let lowdb_node = require("lowdb/node");
+let jiti = require("jiti");
+let string2argv = require("string2argv");
+let node_url = require("node:url");
+let napcat_sdk = require("napcat-sdk");
+let pretty_ms = require("pretty-ms");
+pretty_ms = __toESM(pretty_ms);
+let filesize = require("filesize");
+let dayjs = require("dayjs");
+dayjs = __toESM(dayjs);
+let dedent = require("dedent");
+dedent = __toESM(dedent);
+let systeminformation = require("systeminformation");
+systeminformation = __toESM(systeminformation);
+let node_os = require("node:os");
+node_os = __toESM(node_os);
+let node_child_process = require("node:child_process");
+node_child_process = __toESM(node_child_process);
+let node_cron = require("node-cron");
+node_cron = __toESM(node_cron);
+
+//#region src/logger.ts
+const getMiokiLogger = (level) => {
+	return (0, pino.default)({
+		level,
+		name: "mioki",
+		transport: {
+			target: "pino-pretty",
+			options: { colorize: true }
+		}
+	});
+};
+
+//#endregion
+//#region src/utils.ts
+var utils_exports = /* @__PURE__ */ __export({
+	ChromeUA: () => ChromeUA,
+	START_TIME: () => START_TIME,
+	base64Decode: () => base64Decode,
+	base64Encode: () => base64Encode,
+	bindBot: () => bindBot,
+	clamp: () => clamp,
+	createCmd: () => createCmd,
+	createDB: () => createDB,
+	createStore: () => createStore,
+	dayjs: () => dayjs.default,
+	dedent: () => dedent.default,
+	ensureBuffer: () => ensureBuffer,
+	filesize: () => filesize.filesize,
+	filter: () => filter,
+	find: () => find,
+	formatDuration: () => formatDuration,
+	formatQQLevel: () => formatQQLevel,
+	fs: () => node_fs.default,
+	getAuthCodeViaTicket: () => getAuthCodeViaTicket,
+	getBfaceUrl: () => getBfaceUrl,
+	getGroupAvatarLink: () => getGroupAvatarLink,
+	getImage: () => getImage,
+	getImageUrl: () => getImageUrl,
+	getMentionedImage: () => getMentionedImage,
+	getMentionedImageUrl: () => getMentionedImageUrl,
+	getMentionedUserId: () => getMentionedUserId,
+	getMinicoTokenViaAuthCode: () => getMinicoTokenViaAuthCode,
+	getQQAvatarLink: () => getQQAvatarLink,
+	getQuoteImage: () => getQuoteImage,
+	getQuoteImageUrl: () => getQuoteImageUrl,
+	getQuoteMessage: () => getQuoteMessage,
+	getQuoteText: () => getQuoteText,
+	getTerminalInput: () => getTerminalInput,
+	isBoolean: () => isBoolean,
+	isDefined: () => isDefined,
+	isFunction: () => isFunction,
+	isGroupMsg: () => isGroupMsg,
+	isNumber: () => isNumber,
+	isObject: () => isObject,
+	isPrivateMsg: () => isPrivateMsg,
+	isString: () => isString,
+	jiti: () => jiti$1,
+	localNum: () => localNum,
+	localeDate: () => localeDate,
+	localeTime: () => localeTime,
+	match: () => match,
+	md5: () => md5,
+	mri: () => mri.default,
+	noNullish: () => noNullish,
+	path: () => node_path.default,
+	prettyMs: () => pretty_ms.default,
+	qs: () => qs,
+	queryDevToolsLoginStatus: () => queryDevToolsLoginStatus,
+	randomId: () => randomId,
+	randomInt: () => randomInt,
+	randomItem: () => randomItem,
+	randomItems: () => randomItems,
+	requestLoginViaDevTools: () => requestLoginViaDevTools,
+	runWithReaction: () => runWithReaction,
+	string2argv: () => string2argv.string2argv,
+	stringifyError: () => stringifyError,
+	systemInfo: () => systeminformation.default,
+	text: () => text,
+	toArray: () => toArray,
+	toMsgId: () => toMsgId,
+	unique: () => unique,
+	uuid: () => uuid,
+	wait: () => wait
+});
+const ChromeUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/131.0.0.0";
+/**
+* Jiti 实例
+*/
+const jiti$1 = (0, jiti.createJiti)(__dirname, {
+	extensions: [
+		".ts",
+		".js",
+		".cts",
+		".cjs",
+		".mts",
+		".mjs",
+		".tsx",
+		".jsx",
+		".json"
+	],
+	cache: false,
+	fsCache: false,
+	moduleCache: false,
+	requireCache: false,
+	sourceMaps: false,
+	interopDefault: true,
+	jsx: {
+		importSource: "react",
+		runtime: "automatic"
+	}
+});
+/**
+* 解析命令字符串，返回命令和参数
+*/
+function createCmd(cmdStr, options = {}) {
+	const { prefix = "", onPrefix = () => {} } = options;
+	const { _, ...cmdOptions } = (0, mri.default)((0, string2argv.string2argv)(cmdStr));
+	const [cmd$1, ...params] = _;
+	if (prefix) {
+		if (cmd$1 !== prefix) return {
+			cmd: void 0,
+			params: [],
+			options: cmdOptions
+		};
+		if (params.length === 0) onPrefix();
+		return {
+			cmd: params.shift(),
+			params,
+			options: cmdOptions
+		};
+	}
+	return {
+		cmd: cmd$1,
+		params,
+		options: cmdOptions
+	};
+}
+/**
+* 带有表情反应的函数执行包装器
+*/
+async function runWithReaction(e, fn, id = "60") {
+	await e.addReaction(id);
+	const result = await fn();
+	await e.delReaction(id);
+	return result;
+}
+/**
+* 创建一个 LowDB 数据库实例
+*/
+async function createDB(filename, options = {}) {
+	const { defaultData = {}, compress = false } = options;
+	const database = new lowdb.Low(new lowdb_node.DataFile(filename, {
+		parse: JSON.parse,
+		stringify: (data) => JSON.stringify(data, null, compress ? 0 : 2)
+	}), defaultData);
+	await database.read();
+	return database;
+}
+function ensureBuffer(buffer, text$1 = "图片渲染失败") {
+	return buffer ? napcat_sdk.segment.image(`data:image/png;base64,${buffer.toString("base64")}`) : text$1;
+}
+/**
+* 格式化时间间隔为可读字符串
+*
+* @param ms 时间间隔（毫秒）
+* @returns 可读字符串
+*/
+function formatDuration(ms) {
+	const seconds = Math.floor(ms / 1e3);
+	const minutes = Math.floor(seconds / 60);
+	const hours = Math.floor(minutes / 60);
+	const days = Math.floor(hours / 24);
+	if (days > 0) return `${days}天${hours % 24}小时`;
+	if (hours > 0) return `${hours}小时${minutes % 60}分钟`;
+	if (minutes > 0) return `${minutes}分钟${seconds % 60}秒`;
+	return `${seconds}秒`;
+}
+/**
+* 匹配输入文本与匹配模式，如果匹配成功，则回复匹配结果
+*
+* @param event 消息事件
+* @param pattern 匹配模式
+* @param quote 是否引用回复
+* @returns 匹配结果
+*/
+async function match(event, pattern, quote = true) {
+	const inputText = text(event);
+	for (const [key, value] of Object.entries(pattern)) if (key === inputText) {
+		const res = await (typeof value === "function" ? value() : value);
+		if (res) return event.reply(res, quote);
+	}
+	return null;
+}
+/**
+* 创建一个持久化数据库，基于 createDB 封装
+*/
+async function createStore(defaultData, options) {
+	const { compress = false, __dirname: __dirname$1, importMeta: meta, filename = "data.json" } = options || {};
+	const dirname = __dirname$1 || meta?.dirname || (meta?.url ? node_path.default.dirname((0, node_url.fileURLToPath)(meta.url)) : "");
+	if (!dirname) throw new Error("createStore: options.__dirname or options.meta must be provided");
+	const database = new lowdb.Low(new lowdb_node.DataFile(node_path.default.join(dirname, filename), {
+		parse: JSON.parse,
+		stringify: (data) => JSON.stringify(data, null, compress ? 0 : 2)
+	}), defaultData);
+	await database.read();
+	await database.write();
+	return database;
+}
+function md5(text$1, encoding = "hex") {
+	const hash = node_crypto.default.createHash("md5").update(text$1);
+	if (encoding === "buffer") return hash.digest();
+	return hash.digest(encoding);
+}
+/**
+* 数组去重
+*/
+function unique(array) {
+	return Array.from(new Set(array));
+}
+/**
+* 确保值为数组
+*
+*/
+function toArray(value) {
+	return Array.isArray(value) ? value : [value];
+}
+/**
+* 是否是群消息
+*/
+const isGroupMsg = (event) => {
+	return "group" in event;
+};
+/**
+* 是否是私聊消息
+*/
+const isPrivateMsg = (event) => {
+	return !isGroupMsg(event);
+};
+/**
+* 异步延时函数
+*
+* @param {number} ms 等待毫秒数
+* @return {Promise<void>}
+*/
+async function wait(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* 获取今天的固定日期字符串，可用来作为「稳定随机」的参数，用于签到、每日任务等场景
+*
+* 格式： 2024/12/12，可选控制时区，默认为 'Asia/Shanghai' （亚洲/上海 时区）
+*
+* @param timeZone 指定的时区，默认为 'Asia/Shanghai'
+* @returns 返回当前日期的字符串格式
+*/
+function localeDate(ts = Date.now(), options = {}) {
+	const { locale = "zh-CN", timeZone = "Asia/Shanghai" } = options;
+	const today = ts instanceof Date ? ts : new Date(ts);
+	return new Intl.DateTimeFormat(locale, {
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		timeZone
+	}).format(today);
+}
+/**
+* 获取当前时间的固定时间字符串
+*/
+function localeTime(ts = Date.now(), options = {}) {
+	const { locale = "zh-CN", timeZone = "Asia/Shanghai", seconds = true } = options;
+	const now = ts instanceof Date ? ts : new Date(ts);
+	return new Intl.DateTimeFormat(locale, {
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		hourCycle: "h23",
+		minute: "2-digit",
+		second: seconds ? "2-digit" : void 0,
+		timeZone
+	}).format(now);
+}
+/**
+* 生成指定范围（min ～ max）内的随机整数
+*
+* 额外支持「稳定随机」，继续传入额外参数即可，如果额外参数相同（忽略顺序），则生成的随机数相同
+*/
+function randomInt(min, max, ...hashArgs) {
+	if (min > max) throw new Error("min must be less than or equal to max");
+	if (hashArgs.length === 0) return Math.floor(Math.random() * (max - min + 1)) + min;
+	const sortedArgs = hashArgs.slice().sort((a, b) => {
+		if (typeof a === "number" && typeof b === "number") return a - b;
+		return JSON.stringify(a).localeCompare(JSON.stringify(b));
+	});
+	const hash = md5(JSON.stringify(sortedArgs));
+	const hashValue = Number.parseInt(hash.slice(0, 8), 16);
+	const range = max - min + 1;
+	return (hashValue % range + range) % range + min;
+}
+/**
+* 取数组内随机一项
+*
+* 额外支持「稳定随机」，继续传入额外参数即可，如果额外参数相同（忽略顺序），则生成的随机项
+*/
+function randomItem(array, ...hashArgs) {
+	if (!Array.isArray(array) || !array.length) throw new Error("randomItem: 参数必须是数组，且不能为空");
+	return array[randomInt(0, array.length - 1, ...hashArgs)];
+}
+/**
+* 从数组中随机选出指定数量的项（不重复）
+*
+* 额外支持「稳定随机」，继续传入额外参数即可，如果额外参数相同（忽略顺序），则生成的随机项相同
+*
+* @param array 源数组
+* @param count 要选择的项数量
+* @param hashArgs 稳定随机的额外参数
+* @returns 随机选出的项组成的数组
+*/
+function randomItems(array, count, ...hashArgs) {
+	if (!Array.isArray(array) || !array.length) throw new Error("randomItems: 参数必须是数组，且不能为空");
+	if (count < 0) throw new Error("randomItems: count 必须为非负整数");
+	if (count === 0) return [];
+	if (count > array.length) throw new Error(`randomItems: 要选择的数量 (${count}) 超过了数组长度 (${array.length})`);
+	if (count === array.length) return [...array];
+	const indices = Array.from({ length: array.length }, (_, i) => i);
+	const selected = [];
+	for (let i = 0; i < count; i++) {
+		const randomIdx = randomInt(0, indices.length - i - 1, ...hashArgs, `select_${i}`);
+		selected.push(indices[randomIdx]);
+		const lastIdx = indices.length - 1 - i;
+		[indices[randomIdx], indices[lastIdx]] = [indices[lastIdx], indices[randomIdx]];
+	}
+	const hasString = array.some(isString);
+	const items = selected.map((idx) => array[idx]);
+	return hasString ? items.sort((p, n) => isString(p) && isString(n) ? p.localeCompare(n) : 0) : items;
+}
+/**
+* 包含大写字母与数字的 6 位随机 ID 生成器
+*/
+function randomId() {
+	return Math.random().toString(16).slice(2, 8).toUpperCase();
+}
+/**
+* 简单生成符合 UUID 规范的字符串，但不保证唯一性
+*/
+function uuid() {
+	return `${randStr(8)}-${randStr(4)}-${randStr(4)}-${randStr(4)}-${randStr(12)}`;
+	function randStr(length = 4) {
+		return Math.random().toString(16).substring(2, length + 2);
+	}
+}
+/**
+* clamp 操作，限制数值在指定范围内
+*/
+function clamp(n, min, max) {
+	return Math.min(max, Math.max(min, n));
+}
+/**
+* 排除 null 和 undefined
+*/
+function noNullish(val) {
+	return val !== null && val !== void 0;
+}
+/**
+* 判断是否定义
+*/
+function isDefined(val) {
+	return typeof val !== "undefined";
+}
+/**
+* 通过消息事件生成唯一 id
+*/
+function toMsgId(event) {
+	return `${event.seq}_${event.rand}`;
+}
+/**
+* 判断是否为函数
+*/
+function isFunction(val) {
+	return typeof val === "function";
+}
+/**
+* 判断是否为数字
+*/
+function isNumber(val) {
+	return typeof val === "number";
+}
+/**
+* 判断是否为布尔值
+*/
+function isBoolean(val) {
+	return typeof val === "boolean";
+}
+/**
+* 判断是否为字符串
+*/
+function isString(val) {
+	return typeof val === "string";
+}
+/**
+* 判断是否为对象
+*/
+function isObject(val) {
+	return Object.prototype.toString.call(val) === "[object Object]";
+}
+/**
+* 将数字转换为本地化数字字符串
+*/
+function localNum(num, locale = "zh-CN") {
+	return num.toLocaleString(locale);
+}
+/**
+* 通过 QQ 号获取任意头像链接
+*
+* size 可选： 0 | 40 | 100 | 160 | 640，0 为原图
+*/
+function getQQAvatarLink(qq, size = 640) {
+	return `https://q.qlogo.cn/headimg_dl?dst_uin=${qq}&spec=${size}`;
+}
+/**
+* 通过群号获取任意群头像链接
+*
+* size 可选： 40 | 100 | 640，0 为原图
+*/
+function getGroupAvatarLink(group, size = 640) {
+	return `https://p.qlogo.cn/gh/111111/${group}/${size}`;
+}
+const messageCacheMap = /* @__PURE__ */ new Map();
+/** 获取引用回复的消息 */
+async function getQuoteMessage(event, timeout = 3e3) {
+	if (!event.quote_id) return null;
+	const quote_id = event.quote_id;
+	const key = isGroupMsg(event) ? `${event.group_id}_${quote_id}` : `${event.sender.user_id}_${quote_id}`;
+	const cacheMsg = messageCacheMap.get(key);
+	const isFetching = cacheMsg === "loading";
+	if (cacheMsg !== void 0 && !isFetching) return cacheMsg;
+	if (isFetching) {
+		const start$1 = Date.now();
+		return new Promise((resolve) => {
+			const timer = setInterval(() => {
+				const cacheMsg$1 = messageCacheMap.get(key);
+				if (cacheMsg$1 !== void 0 && !(cacheMsg$1 === "loading")) {
+					clearInterval(timer);
+					resolve(cacheMsg$1);
+				} else if (Date.now() - start$1 > timeout) {
+					clearInterval(timer);
+					throw new Error(`>>> 获取引用消息超时 ${timeout}, Key: ${key}`);
+				}
+			}, 100);
+		});
+	}
+	messageCacheMap.set(key, "loading");
+	const msg = await event.getQuoteMessage();
+	if (messageCacheMap.size > 100) messageCacheMap.clear();
+	messageCacheMap.set(key, msg);
+	return msg;
+}
+/**
+* 获取原创表情包的图片链接
+*/
+async function getBfaceUrl(file) {
+	const id = file.slice(0, 2);
+	const hash = file.slice(0, 32);
+	for (const f of [
+		"raw300.gif",
+		"raw200.gif",
+		"raw100.gif",
+		"300x300.png",
+		"200x200.png",
+		"100x100.png"
+	]) {
+		const url = `https://gxh.vip.qq.com/club/item/parcel/item/${id}/${hash}/${f}`;
+		if ((await fetch(url, { method: "HEAD" })).status === 200) return url;
+	}
+	return null;
+}
+/**
+* 获取消息中的图片链接
+*/
+async function getImageUrl(event) {
+	return find(event, "image")?.url || "";
+}
+/**
+* 获取引用回复的消息中的图片链接
+*/
+async function getQuoteImageUrl(event) {
+	const quoteMsg = await getQuoteMessage(event);
+	if (!quoteMsg) return "";
+	return await getImageUrl(quoteMsg);
+}
+/**
+* 获取消息提及的图片链接（消息或者引用消息）
+*/
+async function getMentionedImageUrl(event) {
+	return await getImageUrl(event) || await getQuoteImageUrl(event);
+}
+/**
+* 获取消息中的图片元素
+*/
+function getImage(event) {
+	return find(Array.isArray(event) ? event : event.message, "image") || null;
+}
+/**
+* 获取引用回复的图片消息
+*/
+async function getQuoteImage(event) {
+	const quoteMsg = await getQuoteMessage(event);
+	if (quoteMsg) return find(quoteMsg.message, "image") || null;
+	return null;
+}
+/**
+* 获取消息提及的图片（消息或者引用消息）
+*/
+async function getMentionedImage(event) {
+	return getImage(event) || await getQuoteImage(event);
+}
+/**
+* 获取消息中的文本内容，默认采取 'whole' 模式，去除整体的首尾空格，可选 'each' 模式，去除每个文本的首尾空格
+*
+* 如: whole 模式下 => '  123    [表情] 456  ' => '123     456'
+* 如: each 模式下 => '  123    [表情] 456  ' => '123456'
+*/
+function text(event, options = {}) {
+	const { trim = true } = options;
+	const texts = (Array.isArray(event) ? event : event.message).filter((msg) => msg.type === "text").map((msg) => msg.text);
+	let result;
+	if (trim === "whole") result = texts.join("").trim();
+	else if (trim === "each") result = texts.map((t) => t.trim()).join("");
+	else if (trim === true) result = texts.map((t) => t.trim()).join("");
+	else result = texts.join("");
+	return result || "";
+}
+/**
+* 获取回复的消息中的文本内容
+*/
+async function getQuoteText(event) {
+	const msg = await getQuoteMessage(event);
+	if (!msg) return "";
+	return text(msg);
+}
+/**
+* 获取提到的用户 QQ 号，可以通过 if(!qq) 判断是否提到了用户，返回 0 代表没有提到用户
+*/
+async function getMentionedUserId(event) {
+	const quoteId = (await getQuoteMessage(event))?.sender.user_id || 0;
+	const msgAtId = +(find(event.message, "at")?.qq || 0);
+	return Number.isNaN(msgAtId) || !msgAtId ? quoteId : msgAtId;
+}
+/**
+* 获取 **一个** 指定类型的消息元素，如获取图片、表情等，如果没有则返回 undefined
+*/
+function find(event, type) {
+	return (Array.isArray(event) ? event : event.message).find((msg) => msg.type === type);
+}
+/**
+* 获取 **所有** 指定类型的消息元素，如获取图片、表情等，如果没有则返回 []
+*/
+function filter(event, type) {
+	return (Array.isArray(event) ? event : event.message).filter((msg) => msg.type === type);
+}
+/**
+* 错误信息字符串格式化
+*
+* @param {any} error 待处理错误
+* @return {string} stringify 结果
+*/
+function stringifyError(error) {
+	if (typeof error === "object") return `${error.constructor?.name ?? "未知错误"}: ${error.message ?? "[无报错信息]"}`;
+	return String(error);
+}
+/**
+* Encodes string | number | buffer using base64.
+*/
+function base64Encode(str) {
+	return Buffer.from(str.toString()).toString("base64");
+}
+/**
+* Decodes the string from base64 to UTF-8.
+*
+* @param {string} str - The base64-encoded string.
+*/
+function base64Decode(str, type = "utf8") {
+	if (type === "buffer") return Buffer.from(str, "base64");
+	return Buffer.from(str, "base64").toString(type);
+}
+/**
+* JS 对象转换成 `urlencoded` 格式字符串 { name: 'Bob', age: 18 } => name=Bob&age=18
+*
+* @param {Record<number | string, any>} obj JS 对象
+* @return {string} 转换后的字符串
+*/
+function qs(obj) {
+	return new URLSearchParams(obj).toString();
+}
+/**
+* 格式化展示 QQ 等级
+*/
+function formatQQLevel(level) {
+	return "👑".repeat(Math.floor(level / 64)) + "☀️".repeat(Math.floor(level % 64 / 16)) + "🌙".repeat(Math.floor(level % 16 / 4)) + "⭐️".repeat(level % 4);
+}
+/**
+* 申请通过开发者工具登录，以获取 Cookie
+*/
+async function requestLoginViaDevTools() {
+	const code = await getDevToolsLoginCode();
+	return {
+		code,
+		url: `https://h5.qzone.qq.com/qqq/code/${code}?_proxy=1&from=ide`
+	};
+	/**
+	* 获取开发者工具登录码
+	*/
+	async function getDevToolsLoginCode() {
+		const response = await fetch("https://q.qq.com/ide/devtoolAuth/GetLoginCode", {
+			method: "GET",
+			headers: {
+				qua: "V1_HT5_QDT_0.70.2209190_x64_0_DEV_D",
+				host: "q.qq.com",
+				accept: "application/json",
+				"content-type": "application/json"
+			}
+		});
+		if (!response.ok) return "";
+		const { code: code$1, data } = await response.json();
+		if (+code$1 !== 0) return "";
+		return data.code ?? "";
+	}
+}
+/**
+* 获取开发者工具登录结果
+*/
+async function queryDevToolsLoginStatus(code) {
+	const response = await fetch(`https://q.qq.com/ide/devtoolAuth/syncScanSateGetTicket?code=${code}`, {
+		method: "GET",
+		headers: {
+			qua: "V1_HT5_QDT_0.70.2209190_x64_0_DEV_D",
+			host: "q.qq.com",
+			accept: "application/json",
+			"content-type": "application/json"
+		}
+	});
+	if (!response.ok) return { status: "Error" };
+	const { code: resCode, data } = await response.json();
+	if (+resCode === 0) {
+		if (+data.ok !== 1) return { status: "Wait" };
+		return {
+			status: "OK",
+			ticket: data.ticket
+		};
+	}
+	if (+resCode === -10003) return { status: "Used" };
+	return { status: "Error" };
+}
+/**
+* 通过开发者工具登录获取 AuthCode
+*/
+async function getAuthCodeViaTicket(ticket, appid) {
+	const response = await fetch("https://q.qq.com/ide/login", {
+		method: "POST",
+		headers: {
+			qua: "V1_HT5_QDT_0.70.2209190_x64_0_DEV_D",
+			host: "q.qq.com",
+			accept: "application/json",
+			"content-type": "application/json"
+		},
+		body: JSON.stringify({
+			appid,
+			ticket
+		})
+	});
+	if (!response.ok) return "";
+	const { code } = await response.json();
+	return code || "";
+}
+/**
+* 通过 Auth Code 获取 minico Token
+*/
+async function getMinicoTokenViaAuthCode(authCode, appid) {
+	const response = await fetch("https://minico.qq.com/minico/oauth20?uin=QQ%E5%AE%89%E5%85%A8%E4%B8%AD%E5%BF%83", {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			appid,
+			code: authCode,
+			platform: "qq"
+		})
+	});
+	if (!response.ok) return {};
+	const { retcode, data } = await response.json();
+	if (+retcode !== 0 || !data) return {};
+	return data || {};
+}
+/**
+* 获取终端输入，返回 Promise，支持提示信息
+*/
+async function getTerminalInput(inputTip = "请输入") {
+	return new Promise((resolve) => {
+		if (inputTip) console.log(inputTip);
+		function getInput() {
+			process.stdin.once("data", async (e) => {
+				const input = e.toString().trim();
+				if (input) {
+					resolve(input);
+					return;
+				}
+				getInput();
+			});
+		}
+		getInput();
+	});
+}
+function bindBot(bot, func) {
+	return (...args) => func(bot, ...args);
+}
+/**
+* 当前 Node.js 进程的启动时间，常量，Date 类型
+*/
+const START_TIME = /* @__PURE__ */ new Date();
+
+//#endregion
+//#region src/config.ts
+var config_exports = /* @__PURE__ */ __export({
+	BOT_CWD: () => BOT_CWD,
+	botConfig: () => botConfig,
+	getLogFilePath: () => getLogFilePath,
+	hasRight: () => hasRight,
+	isAdmin: () => isAdmin,
+	isInPm2: () => isInPm2,
+	isOwner: () => isOwner,
+	isOwnerOrAdmin: () => isOwnerOrAdmin,
+	readMiokiConfig: () => readMiokiConfig,
+	readPackageJson: () => readPackageJson,
+	updateBotCWD: () => updateBotCWD,
+	updateBotConfig: () => updateBotConfig,
+	writePackageJson: () => writePackageJson
+});
+/**
+* 机器人根目录
+*/
+const BOT_CWD = { value: process.cwd() };
+function readPackageJson() {
+	if (!node_fs.default.existsSync(node_path.default.join(BOT_CWD.value, "package.json"))) throw new Error(`无法在 ${BOT_CWD.value} 下找到 package.json 文件，请确认当前目录是否为机器人根目录`);
+	return JSON.parse(node_fs.default.readFileSync(node_path.default.join(BOT_CWD.value, "package.json"), "utf-8")) || {};
+}
+function writePackageJson(pkg) {
+	node_fs.default.writeFileSync(node_path.default.join(BOT_CWD.value, "package.json"), JSON.stringify(pkg, null, 2), "utf-8");
+}
+function readMiokiConfig() {
+	const config = readPackageJson().mioki;
+	if (!config) throw new Error(`无法在 package.json 中找到 mioki 配置，请确认 package.json 文件中是否包含 mioki 字段`);
+	if (!config.napcat) throw new Error(`mioki 配置中缺少 napcat 字段，请补全后重试`);
+	return readPackageJson().mioki;
+}
+/**
+* `mioki` 框架相关配置
+*/
+const botConfig = readMiokiConfig();
+/**
+* 更新 `mioki` 配置，同时同步更新本地配置文件
+*/
+const updateBotConfig = async (draftFn) => {
+	await draftFn(botConfig);
+	botConfig.plugins = unique(botConfig.plugins).toSorted((prev, next) => prev.localeCompare(next));
+	botConfig.admins = unique(botConfig.admins).toSorted((prev, next) => prev - next);
+	const pkg = readPackageJson();
+	pkg.mioki = structuredClone(botConfig);
+	writePackageJson(pkg);
+	console.log(`>>> 检测到配置变动，已同步至 package.json 文件`);
+};
+/**
+* 更新机器人根目录
+*/
+const updateBotCWD = (root) => {
+	BOT_CWD.value = root;
+	console.log(`>>> 机器人根目录已设置为 ${root}`);
+};
+/**
+* 是否是主人
+*/
+const isOwner = (id) => {
+	const owners = botConfig.owners;
+	return isNumber(id) ? owners.includes(id) : "sender" in id ? owners.includes(id.sender.user_id) : owners.includes(id.user_id);
+};
+/**
+* 是否是管理员，注意: 主人不是管理员
+*/
+const isAdmin = (id) => {
+	const admins = botConfig.admins;
+	return isNumber(id) ? admins.includes(id) : "sender" in id ? admins.includes(id.sender.user_id) : admins.includes(id.user_id);
+};
+/**
+* 是否是主人或管理员
+*/
+const isOwnerOrAdmin = (id) => {
+	return isOwner(id) || isAdmin(id);
+};
+/**
+* 是否有权限，即：主人或管理员
+*/
+const hasRight = (id) => {
+	return isOwnerOrAdmin(id);
+};
+/**
+* 是否在 PM2 中运行
+*/
+const isInPm2 = Boolean("pm_id" in process.env || "PM2_USAGE" in process.env);
+/**
+* 获取日志文件名
+*/
+function getLogFilePath(uin, platformName) {
+	const startTime = (0, dayjs.default)().format("YYYY-MM-DD_HH-mm-ss");
+	return node_path.default.join(BOT_CWD.value, `logs/${uin}_${platformName}_${startTime}.log`);
+}
+
+//#endregion
+//#region package.json
+var version = "0.2.1";
+
+//#endregion
+//#region src/actions.ts
+var actions_exports = /* @__PURE__ */ __export({
+	createForwardMsg: () => createForwardMsg,
+	getViolationRecords: () => getViolationRecords,
+	noticeAdmins: () => noticeAdmins,
+	noticeFriends: () => noticeFriends,
+	noticeGroups: () => noticeGroups,
+	noticeMainOwner: () => noticeMainOwner,
+	noticeOwners: () => noticeOwners,
+	runWithErrorHandler: () => runWithErrorHandler,
+	signArk: () => signArk,
+	uploadImageToCollection: () => uploadImageToCollection,
+	uploadImageToGroupHomework: () => uploadImageToGroupHomework,
+	uploadImageToGroupNotice: () => uploadImageToGroupNotice
+});
+/**
+* 群发群消息
+*/
+async function noticeGroups(bot, groupIdList, message, delay = 1e3) {
+	if (!bot.isOnline()) {
+		bot.logger.error("发送失败，Bot 不在线");
+		return;
+	}
+	if (!message) {
+		bot.logger.warn("消息内容为空");
+		return;
+	}
+	for (const groupId of groupIdList) {
+		const group = await bot.pickGroup(groupId);
+		if (!group) continue;
+		await group.sendMsg(message);
+		await wait(delay);
+	}
+}
+/**
+* 群发好友消息
+*/
+async function noticeFriends(bot, friendIdList, message, delay = 1e3) {
+	if (!bot.isOnline) {
+		bot.logger.error("发送失败，Bot 不在线");
+		return;
+	}
+	if (!message) {
+		bot.logger.warn("消息内容为空");
+		return;
+	}
+	for (const friendId of friendIdList) {
+		const friend = await bot.pickFriend(friendId);
+		if (!friend) continue;
+		await friend.sendMsg(message);
+		await wait(delay);
+	}
+}
+/**
+* 群发通知给管理员
+*/
+async function noticeAdmins(bot, message, delay = 1e3) {
+	await noticeFriends(bot, botConfig.admins, message, delay);
+}
+/**
+* 群发通知给主人
+*/
+async function noticeOwners(bot, message, delay = 1e3) {
+	await noticeFriends(bot, botConfig.owners, message, delay);
+}
+/**
+* 群发通知给第一个主人
+*/
+async function noticeMainOwner(bot, message) {
+	if (!bot.isOnline()) {
+		bot.logger.error("发送失败，Bot 不在线");
+		return;
+	}
+	if (!message) {
+		bot.logger.warn("消息内容为空");
+		return;
+	}
+	const mainOwner = botConfig.owners[0];
+	if (mainOwner) {
+		await (await bot.pickFriend(mainOwner))?.sendMsg(message);
+		return;
+	}
+	throw new Error("请至少设置一个主人");
+}
+/**
+* 签名卡片 json
+*/
+async function signArk(bot, json) {
+	const { cookie, gtk } = await bot.getCookie("qzone.qq.com");
+	const fetchArk = (url) => {
+		return fetch(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Cookie: cookie
+			},
+			body: JSON.stringify({ ark: json })
+		});
+	};
+	const SignUrl = {
+		normal: `https://h5.qzone.qq.com/v2/vip/tx/trpc/ark-share/GenSignedArk?g_tk=${gtk}`,
+		new: `https://h5.qzone.qq.com/v2/vip/tx/trpc/ark-share/GenNewSignedArk?g_tk=${gtk}`
+	};
+	try {
+		const { code, data = {} } = await (await fetchArk(SignUrl.normal)).json();
+		if (+code === 0 && data?.signed_ark) return data.signed_ark;
+		throw new Error("签不了一点");
+	} catch {
+		const { code, data = {} } = await (await fetchArk(SignUrl.new)).json();
+		if (+code === 0 && data?.signed_ark) return data.signed_ark;
+		throw new Error("签不了一点");
+	}
+}
+/**
+* 运行函数并捕获错误, 并通过 event.reply 发送错误信息
+*/
+async function runWithErrorHandler(bot, fn, event, message = (err) => `报...报错了啦！ 杂鱼~ 杂鱼~ \n\n${err}`) {
+	try {
+		return await fn();
+	} catch (error) {
+		const errorMsg = typeof message === "function" ? message(stringifyError(error)) : message;
+		if (event) await event.reply(errorMsg);
+		else try {
+			await noticeMainOwner(bot, "发送失败，可能被风控，请检查签名状态。");
+		} catch {
+			bot.logger.error("发送失败，可能被风控，请检查签名状态。");
+		}
+	}
+}
+/** 创建和并转发消息 */
+function createForwardMsg(bot, message = [], options = {}) {
+	const { user_id = bot.uin, nickname } = options;
+	const content = message.map((msg) => typeof msg === "string" ? napcat_sdk.segment.text(msg) : msg);
+	return napcat_sdk.segment.node({
+		user_id: String(user_id),
+		nickname,
+		content
+	});
+}
+/**
+* 上传图片到收藏
+*/
+async function uploadImageToCollection(bot, buffer) {
+	const pskey = await bot.getPskey("weiyun.com") || "";
+	const uuid$1 = node_crypto.default.randomUUID();
+	let randomID = node_crypto.default.randomInt(1, 99);
+	if (randomID < 10) randomID = `0${randomID}`;
+	const options = {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/octet-stream",
+			Cookie: `uin=${bot.uin}; vt=27; vi=${pskey}; pid=00${randomID}/${uuid$1}; appid=30243`,
+			"User-Agent": "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)"
+		},
+		body: buffer
+	};
+	let code = void 0;
+	for (let i = 3; i > 0; i--) {
+		const response = await fetch("https://uploader.collector.weiyun.com/pic_uploader.fcg", options);
+		const headers = response.headers;
+		code = +(headers.get("user-returncode") || "");
+		const msg = headers.get("user-errmsg");
+		console.log(3 - i, "uploadImageToCollector", response.status, code, msg);
+		if (code === 0) break;
+	}
+	return code === 0 ? `https://shp.qpic.cn/collector//${uuid$1}/0` : "";
+}
+/**
+* 上传图片到群作业
+*/
+async function uploadImageToGroupHomework(bot, imgBase64) {
+	const { cookie, bkn } = await bot.getCookie("qun.qq.com");
+	const data = await (await fetch("https://qun.qq.com/cgi-bin/hw/util/image", {
+		method: "POST",
+		headers: {
+			cookie,
+			"Content-Type": "application/x-www-form-urlencoded",
+			origin: "https://qun.qq.com",
+			referer: "https://qun.qq.com/homework/p/features/index.html"
+		},
+		body: `pic=${encodeURIComponent(imgBase64)}&client_type=1&bkn=${bkn}`
+	})).json();
+	if (+data.retcode !== 0) return "";
+	return data?.data?.url?.origin || "";
+}
+/**
+* 上传图片到群公告
+*/
+async function uploadImageToGroupNotice(bot, urlOrBlob) {
+	const { bkn, legacyCookie } = await bot.getCookie("qun.qq.com");
+	const blob = urlOrBlob instanceof Blob ? urlOrBlob : await (await fetch(urlOrBlob)).blob();
+	const form = new FormData();
+	form.append("m", "0");
+	form.append("source", "troopNotice");
+	form.append("bkn", String(bkn));
+	form.append("qid", "0");
+	form.append("pic_up", blob, `image.${blob.type.split("/")[1]}`);
+	const { id, ec } = await (await fetch("https://web.qun.qq.com/cgi-bin/announce/upload_img", {
+		method: "POST",
+		body: form,
+		headers: {
+			"content-type": "multipart/form-data",
+			cookie: legacyCookie
+		}
+	})).json() || {};
+	if (!id) throw new Error(`图片上传失败，ec: ${ec}`);
+	const imgData = JSON.parse(id.replace(/&quot;/g, "\"")) || {};
+	if (!imgData.id) throw new Error("图片上传失败，未获取到图片 id");
+	return {
+		...imgData,
+		url: `https://p.qpic.cn/gdynamic/${imgData.id}/0`,
+		url2: `https://p.qlogo.cn/gdynamic/${imgData.id}/0`,
+		url3: `https://p2.qpic.cn/gdynamic/${imgData.id}/0`,
+		url4: `https://gdynamic.qpic.cn/gdynamic/${imgData.id}/0`,
+		url5: `https://img.wecar.qq.com/gdynamic/${imgData.id}/0`,
+		url6: `https://cross.store.qq.com/gdynamic/${imgData.id}/0`
+	};
+}
+/**
+* 获取 QQ 安全中心违规记录
+*/
+async function getViolationRecords(bot, authCode, appid, size = 100) {
+	const minicoData = await getMinicoTokenViaAuthCode(authCode, appid);
+	if (!minicoData) return [];
+	const params = new URLSearchParams({
+		...minicoData,
+		appid,
+		token: minicoData.minico_token
+	});
+	params.delete("expire");
+	params.delete("minico_token");
+	const { retcode, records } = await (await fetch(`https://minico.qq.com/minico/cgiproxy/v3_release/v3/getillegalityhistory?${params.toString()}`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			com: {
+				src: 0,
+				scene: 1001,
+				platform: 2,
+				version: "8.9.85.12820"
+			},
+			pageNum: 0,
+			pageSize: size
+		})
+	})).json();
+	if (+retcode !== 0 || !records) return [];
+	return records || [];
+}
+
+//#endregion
+//#region src/services.ts
+const USER_SERVICE = {};
+/**
+* 服务，由其他插件贡献的方法、数据等
+*/
+const services = USER_SERVICE;
+/**
+* 给 `Mioki` 添加公共服务，可用于插件间通信和共享数据
+*
+* 请注意合理设置插件的 `priority` 属性，以确保服务的正确加载顺序，`priority` 默认为 100，越小越先加载
+*
+* 建议需要调用 `addService` 的插件设置 `priority` 为 `10`
+*/
+function addService(name, service, cover = true) {
+	if (cover || !USER_SERVICE[name]) USER_SERVICE[name] = service;
+	return () => USER_SERVICE[name] = void 0;
+}
+
+//#endregion
+//#region src/plugin.ts
+const runtimePlugins = /* @__PURE__ */ new Map();
+const buildRemovedActions = (bot) => Object.fromEntries(Object.entries(actions_exports).map(([k, v]) => [k, bindBot(bot, v)]));
+/**
+* 定义一个 Mioki 插件
+* @param plugin Mioki 插件对象
+* @returns Mioki 插件对象
+*/
+function definePlugin(plugin) {
+	return plugin;
+}
+/**
+* 确保插件目录存在
+*/
+function ensurePluginDir() {
+	const dir = getAbsPluginDir();
+	if (!node_fs.default.existsSync(dir)) node_fs.default.mkdirSync(dir, { recursive: true });
+}
+/**
+* 获取插件目录的绝对路径
+*/
+function getAbsPluginDir(defaultDir = "plugin") {
+	const cwd = BOT_CWD.value;
+	return node_path.default.resolve(cwd, botConfig.plugin_dir || defaultDir);
+}
+async function enablePlugin(bot, plugin, type = "external") {
+	const typeDesc = type === "builtin" ? "内置" : "用户";
+	const pluginName = plugin.name || "null";
+	const { name = pluginName, version: version$1 = "null", description = "-", setup = () => {} } = plugin;
+	try {
+		const start$1 = node_process.hrtime.bigint();
+		const clears = /* @__PURE__ */ new Set();
+		const userClears = /* @__PURE__ */ new Set();
+		const context = {
+			bot,
+			segment: bot.segment,
+			...utils_exports,
+			...config_exports,
+			...buildRemovedActions(bot),
+			services,
+			clears: userClears,
+			addService: (name$1, service, cover) => {
+				const removeService = addService(name$1, service, cover);
+				clears.add(removeService);
+				return removeService;
+			},
+			handle: (eventName, handler) => {
+				bot.on(eventName, handler);
+				const unsubscribe = () => bot.off(eventName, handler);
+				clears.add(unsubscribe);
+				return unsubscribe;
+			},
+			cron: (cronExpression, handler) => {
+				const job = node_cron.default.schedule(cronExpression, (now) => handler(context, now));
+				const clear = () => job.stop();
+				clears.add(clear);
+				return job;
+			}
+		};
+		clears.add(await setup(context) || (() => {}));
+		runtimePlugins.set(name, {
+			name,
+			type,
+			version: version$1,
+			description,
+			plugin,
+			disable: async () => {
+				try {
+					await Promise.all([...clears, ...userClears].map((fn) => fn?.()));
+					runtimePlugins.delete(name);
+				} catch (err) {
+					throw new Error(`禁用插件 [${typeDesc}]${name}@${version$1} 失败: ${err?.message}`);
+				}
+			}
+		});
+		const end = node_process.hrtime.bigint();
+		const time = Math.round(Number(end - start$1)) / 1e6;
+		bot.logger.info(`启用插件 [${typeDesc}]${name}@${version$1} => 耗时 ${time} ms`);
+	} catch (e) {
+		throw new Error(`启用插件 [${typeDesc}]${name}@${version$1} 失败: ${e?.message}`);
+	}
+	return plugin;
+}
+async function findLocalPlugins() {
+	return (await node_fs.default.promises.readdir(getAbsPluginDir(), { withFileTypes: true })).filter((e) => e.isDirectory() && !!e.name && !e.name.startsWith("_")).map((e) => ({
+		name: e.name,
+		absPath: node_path.default.join(getAbsPluginDir(), e.name)
+	}));
+}
+
+//#endregion
+//#region src/builtins/cmd/status.ts
+const SystemMap = {
+	Linux: "Linux",
+	Darwin: "macOS",
+	Windows_NT: "Win"
+};
+const ArchMap = {
+	ia32: "x86",
+	arm: "arm",
+	arm64: "arm64",
+	x64: "x64"
+};
+async function getMiokiStatus(bot) {
+	const osType = node_os.default.type();
+	const osArch = node_os.default.arch();
+	const isInUnix = ["Linux", "Darwin"].includes(osType);
+	const arch = ArchMap[osArch] || osArch;
+	const [osInfo, localPlugins, versionInfo] = await Promise.all([
+		systeminformation.default.osInfo(),
+		findLocalPlugins(),
+		bot.getVersionInfo()
+	]);
+	const pluginCount = localPlugins.length + BUILTIN_PLUGINS.length;
+	const system = isInUnix ? {
+		name: osInfo.distro,
+		version: osInfo.release
+	} : {
+		name: SystemMap[osType] || osType,
+		version: "-"
+	};
+	const totalMem = node_os.default.totalmem();
+	const usedMem = totalMem - node_os.default.freemem();
+	const rssMem = process.memoryUsage.rss();
+	const nodeVersion = process.versions.node;
+	const cpu = getCpuInfo();
+	return {
+		bot: {
+			uin: bot.uin,
+			nickname: bot.nickname
+		},
+		plugins: {
+			enabled: runtimePlugins.size,
+			total: pluginCount
+		},
+		stats: { uptime: process.uptime() * 1e3 },
+		versions: {
+			node: nodeVersion,
+			mioki: version,
+			napcat: versionInfo.app_version,
+			protocol: versionInfo.protocol_version
+		},
+		system: {
+			name: system.name,
+			version: system.version,
+			arch
+		},
+		memory: {
+			used: usedMem,
+			total: totalMem,
+			percent: Number((usedMem / totalMem * 100).toFixed(1)),
+			rss: {
+				used: rssMem,
+				percent: Number((rssMem / totalMem * 100).toFixed(1))
+			}
+		},
+		disk: isInUnix ? await getDiskUsageInUnix() : {
+			total: 0,
+			used: 0,
+			free: 0,
+			percent: 0
+		},
+		cpu: {
+			name: cpu.name,
+			count: cpu.count,
+			percent: Number((await measureCpuUsage()).toFixed(1))
+		}
+	};
+}
+async function getMiokiStatusStr(client) {
+	const { bot, plugins, stats, system, disk, cpu, memory, versions } = await getMiokiStatus(client);
+	const diskValid = disk.total > 0 && disk.free >= 0;
+	const diskDesc = `${disk.percent}%-${(0, filesize.filesize)(disk.used, { round: 1 })}/${(0, filesize.filesize)(disk.total, { round: 1 })}`;
+	return `
+👤 ${bot.nickname}
+🆔 ${bot.uin}
+🧩 启用了 ${localNum(plugins.enabled)} 个插件，共 ${localNum(plugins.total)} 个
+🚀 ${(0, filesize.filesize)(memory.rss.used, { round: 1 })}/${memory.percent}%
+⏳ 已运行 ${(0, pretty_ms.default)(stats.uptime, {
+		hideYear: true,
+		secondsDecimalDigits: 0
+	})}
+🤖 NapCat/${versions.napcat}-mioki/${versions.mioki}
+🖥️ ${system.name.split(" ")[0]}/${system.version.split(".")[0]}-${system.name}-node/${versions.node.split(".")[0]}
+📊 ${memory.percent}%-${(0, filesize.filesize)(memory.used, {
+		base: 2,
+		round: 1
+	})}/${(0, filesize.filesize)(memory.total, {
+		base: 2,
+		round: 1
+	})}
+🧮 ${cpu.percent}%-${cpu.name}-${cpu.count}核
+💾 ${diskValid ? diskDesc : "N/A (不适用)"}
+  `.trim();
+}
+async function getDiskUsageInUnix(path$6 = "/") {
+	return new Promise((resolve) => {
+		node_child_process.default.exec(`df -k ${path$6} | tail -1 | awk '{print $2,$4}'`, (err, stdout) => {
+			if (err) {
+				console.error(err);
+				return resolve({
+					total: 0,
+					used: 0,
+					free: 0,
+					percent: 0
+				});
+			}
+			const [_total, _free] = stdout.trim().split(" ");
+			const total = Number(_total) * 1024;
+			const free = Number(_free) * 1024;
+			const used = total - free;
+			resolve({
+				total,
+				free,
+				used,
+				percent: Number((used / total * 100).toFixed(1))
+			});
+		});
+	});
+}
+async function measureCpuUsage(interval = 600) {
+	const start$1 = getCpuTimes();
+	await new Promise((resolve) => setTimeout(resolve, interval));
+	const end = getCpuTimes();
+	return (1 - (end.idle - start$1.idle) / (end.total - start$1.total)) * 100;
+}
+function getCpuTimes() {
+	const cpus = node_os.default.cpus();
+	let idle = 0;
+	let total = 0;
+	for (const cpu of cpus) {
+		for (const type in cpu.times) total += cpu.times[type];
+		idle += cpu.times.idle;
+	}
+	return {
+		idle,
+		total
+	};
+}
+function getCpuInfo() {
+	const cpus = node_os.default.cpus();
+	return {
+		name: cpus[0]?.model || "[未知CPU]",
+		count: cpus.length
+	};
+}
+
+//#endregion
+//#region src/builtins/cmd/index.ts
+const corePlugins = ["mioki-cmd"];
+const cmd = definePlugin({
+	name: "kivi-cmd",
+	version,
+	priority: 1,
+	setup(ctx) {
+		const prefix = (ctx.botConfig.prefix ?? "#").replace(/[-_.^$?[\]{}]/g, "\\$&");
+		const cmdPrefix = /* @__PURE__ */ new RegExp(`^${prefix}`);
+		const displayPrefix = prefix.replace(/\\\\/g, "\\");
+		ctx.addService("miokiStatus", () => getMiokiStatus(ctx.bot));
+		ctx.handle("message", (e) => ctx.runWithErrorHandler(async () => {
+			const text$1 = ctx.text(e);
+			if (!cmdPrefix.test(text$1)) return;
+			if (text$1.replace(cmdPrefix, "") === "状态") {
+				const status = await getMiokiStatusStr(ctx.bot);
+				await e.reply(`〓 🟢 mioki 状态 〓\n${status}`.trim());
+				return;
+			}
+			if (!ctx.isOwner(e)) return;
+			const { _: params, ..._options } = (0, mri.default)((0, string2argv.string2argv)(text$1));
+			const cmd$1 = params.shift()?.replace(cmdPrefix, "") ?? "";
+			const [subCmd, target, ..._subParams] = params;
+			switch (cmd$1) {
+				case "帮助":
+					await e.reply((0, dedent.default)(`
+              〓 💡 mioki 帮助 〓
+              ${displayPrefix}插件 👉 框架插件管理
+              ${displayPrefix}状态 👉 显示框架状态
+              ${displayPrefix}设置 👉 框架设置管理
+              ${displayPrefix}帮助 👉 显示帮助信息
+              ${displayPrefix}退出 👉 退出框架进程
+              `).trim());
+					break;
+				case "插件":
+					if (corePlugins.includes(target)) {
+						await e.reply("内置插件无法操作", true);
+						return;
+					}
+					switch (subCmd) {
+						case "列表": {
+							const plugins = unique([...(await findLocalPlugins()).map((e$1) => e$1.name), ...runtimePlugins.keys()]).map((name) => {
+								const isEnable = runtimePlugins.get(name);
+								return `${isEnable ? "🟢" : "🔴"} ${isEnable && isEnable?.type === "builtin" ? "[内置]" : "[用户]"} ${name}`;
+							}).toSorted((pre, next) => {
+								function weight(str) {
+									let w = 0;
+									if (str.includes("🟢")) w += 10;
+									if (str.includes("[内置]")) w += 1;
+									return w;
+								}
+								const preWeight = weight(pre);
+								return weight(next) - preWeight || pre.localeCompare(next);
+							});
+							await e.reply((0, dedent.default)(`
+                    〓 插件列表 〓
+                    ${plugins.join("\n")}
+                    共 ${plugins.length} 个，启用 ${runtimePlugins.size} 个
+                    `).trim());
+							break;
+						}
+						case "启用": {
+							if (!target) {
+								await e.reply("请指定插件 ID", true);
+								return;
+							}
+							if (runtimePlugins.has(target)) {
+								await e.reply(`插件 ${target} 已经是启用状态`, true);
+								return;
+							}
+							const pluginPath = node_path.default.join(BOT_CWD.value, "plugins", target);
+							if (!node_fs.default.existsSync(pluginPath)) {
+								await e.reply(`插件 ${target} 不存在`, true);
+								return;
+							}
+							try {
+								const plugin = await jiti$1.import(pluginPath, { default: true });
+								if (plugin.name !== target) {
+									const tip = `[插件目录名称: ${target}] 和插件代码中设置的 [name: ${plugin.name}] 不一致，可能导致重载异常，请修改后重启。`;
+									ctx.bot.logger.warn(tip);
+									ctx.noticeMainOwner(tip);
+								}
+								await enablePlugin(ctx.bot, plugin);
+							} catch (err) {
+								await e.reply(`插件 ${target} 启用失败：${err?.message || "未知错误"}`, true);
+								return;
+							}
+							await updateBotConfig((c) => c.plugins = [...botConfig.plugins, target]);
+							await e.reply(`插件 ${target} 启用成功`, true);
+							break;
+						}
+						case "禁用": {
+							if (!target) {
+								await e.reply("请指定插件 ID", true);
+								return;
+							}
+							const plugin = runtimePlugins.get(target);
+							if (!plugin) {
+								await e.reply(`插件 ${target} 不存在`, true);
+								return;
+							}
+							try {
+								await plugin.disable();
+							} catch (err) {
+								await e.reply(err?.message, true);
+								break;
+							}
+							await updateBotConfig((c) => c.plugins = botConfig.plugins.filter((name) => name !== target));
+							ctx.bot.logger.info(`禁用插件 => ${target}`);
+							await e.reply(`插件 ${target} 已禁用`, true);
+							break;
+						}
+						case "重载": {
+							if (!target) {
+								await e.reply("请指定插件 ID", true);
+								return;
+							}
+							let isOff = false;
+							const plugin = runtimePlugins.get(target);
+							try {
+								if (plugin) await plugin.disable();
+								const pluginPath = node_path.default.join(BOT_CWD.value, "plugins", target);
+								if (!node_fs.default.existsSync(pluginPath)) {
+									await e.reply(`插件 ${target} 不存在`, true);
+									return;
+								}
+								if (!plugin) isOff = true;
+								const importedPlugin = await jiti$1.import(pluginPath, { default: true });
+								if (importedPlugin.name !== target) {
+									const tip = `插件目录名称: ${target} 和插件代码中设置的 name: ${importedPlugin.name} 不一致，可能导致重载异常，请修改后重启。`;
+									ctx.bot.logger.warn(tip);
+									ctx.noticeMainOwner(tip);
+								}
+								await enablePlugin(ctx.bot, importedPlugin);
+							} catch (err) {
+								await e.reply(err?.message, true);
+								await updateBotConfig((c) => c.plugins = c.plugins.filter((name) => name !== target));
+								break;
+							}
+							await updateBotConfig((c) => c.plugins = [...c.plugins, target]);
+							await e.reply(`插件 ${target} 已${isOff ? "直接启用" : "重载"}`, true);
+							break;
+						}
+						default:
+							await e.reply((0, dedent.default)(`
+                  〓 🧩 mioki 插件 〓
+                  ${displayPrefix}插件 列表
+                  ${displayPrefix}插件 启用 <插件 ID>
+                  ${displayPrefix}插件 禁用 <插件 ID>
+                  ${displayPrefix}插件 重载 <插件 ID>
+                  `).trim());
+							break;
+					}
+					break;
+				case "设置":
+					switch (subCmd) {
+						case "详情":
+							await e.reply((0, dedent.default)(`
+                  〓 设置详情 〓
+                  主人: ${botConfig.owners.join(", ")}
+                  管理: ${botConfig.admins.join(", ").trim()}
+                  启用插件: ${botConfig.plugins.join(", ").trim()}
+                  `).trim());
+							break;
+						case "加主人":
+						case "添加主人": {
+							const inputUid = Number.parseInt(target);
+							const uid = Number.isNaN(inputUid) ? +(e.message.find((e$1) => e$1.type === "at")?.qq || 0) : inputUid || 0;
+							if (!uid || Number.isNaN(uid)) {
+								await e.reply("请指定主人 QQ/AT", true);
+								return;
+							}
+							if (botConfig.owners.includes(uid)) {
+								await e.reply(`主人 ${uid} 已存在`, true);
+								return;
+							}
+							await updateBotConfig((c) => c.owners = [...c.owners, uid]);
+							await e.reply(`已添加主人 ${uid}`, true);
+							break;
+						}
+						case "删主人":
+						case "删除主人": {
+							const inputUid = Number.parseInt(target);
+							const uid = Number.isNaN(inputUid) ? +(e.message.find((e$1) => e$1.type === "at")?.qq || 0) : inputUid || 0;
+							if (!uid || Number.isNaN(uid)) {
+								await e.reply("请指定主人 QQ/AT", true);
+								return;
+							}
+							if (uid === ctx.botConfig.admins[0]) {
+								await e.reply("不能删除第一主人", true);
+								return;
+							}
+							const idx = botConfig.owners.indexOf(uid);
+							if (idx === -1) {
+								await e.reply(`主人 ${uid} 不存在`, true);
+								return;
+							}
+							await updateBotConfig((c) => c.owners.splice(idx, 1));
+							await e.reply(`已删除主人 ${uid}`, true);
+							break;
+						}
+						case "加管理":
+						case "添加管理": {
+							const inputUid = Number.parseInt(target);
+							const uid = Number.isNaN(inputUid) ? +(e.message.find((e$1) => e$1.type === "at")?.qq || 0) : inputUid || 0;
+							if (!uid || Number.isNaN(uid)) {
+								await e.reply("请指定管理 QQ/AT", true);
+								return;
+							}
+							if (botConfig.admins.includes(uid)) {
+								await e.reply(`管理 ${uid} 已存在`, true);
+								return;
+							}
+							await updateBotConfig((c) => c.admins = [...c.admins, uid]);
+							await e.reply(`已添加管理 ${uid}`, true);
+							break;
+						}
+						case "删管理":
+						case "删除管理": {
+							const inputUid = Number.parseInt(target);
+							const uid = Number.isNaN(inputUid) ? +(e.message.find((e$1) => e$1.type === "at")?.qq || 0) : inputUid || 0;
+							if (!uid || Number.isNaN(uid)) {
+								await e.reply("请指定管理 QQ/AT", true);
+								return;
+							}
+							const idx = botConfig.admins.indexOf(uid);
+							if (idx === -1) {
+								await e.reply(`管理 ${uid} 不存在`, true);
+								return;
+							}
+							await updateBotConfig((c) => c.admins.splice(idx, 1));
+							await e.reply(`已删除管理 ${uid}`, true);
+							break;
+						}
+						default:
+							await e.reply((0, dedent.default)(`
+                  〓 ⚙️ mioki 设置 〓
+                  ${displayPrefix}设置 详情
+                  ${displayPrefix}设置 [加/删]主人 <QQ/AT>
+                  ${displayPrefix}设置 [加/删]管理 <QQ/AT>
+                  `).trim());
+							break;
+					}
+					break;
+				case "退出":
+					await e.reply("またね～", true);
+					ctx.bot.logger.info("接收到退出指令，即将退出... 如需自动重启，请使用 pm2 部署。");
+					process.exit(0);
+			}
+		}, e));
+	}
+});
+var cmd_default = cmd;
+
+//#endregion
+//#region src/builtins/index.ts
+const BUILTIN_PLUGINS = [cmd_default];
+
+//#endregion
+//#region src/start.ts
+async function start(options = {}) {
+	const { cwd = process.cwd() } = options;
+	if (cwd !== BOT_CWD.value) updateBotCWD(cwd);
+	process.title = `mioki v${version}`;
+	const logger = getMiokiLogger(botConfig.log_level || "info");
+	const plugin_dir = getAbsPluginDir();
+	logger.info(`>>> mioki v${version} 启动中，工作目录: ${BOT_CWD.value}，插件目录: ${plugin_dir}`);
+	const napcat = new napcat_sdk.NapCat({
+		...botConfig.napcat,
+		logger
+	});
+	napcat.on("napcat.connected", async ({ uin }) => {
+		logger.info(`>>> 已连接到 NapCat 服务器，当前登录 QQ 账号: ${uin}`);
+		let lastNoticeTime = 0;
+		process.on("uncaughtException", async (err) => {
+			napcat.logger.error(">>> uncaughtException, 出错了", err);
+			if (Date.now() - lastNoticeTime < 1e3) return;
+			lastNoticeTime = Date.now();
+			await noticeMainOwner(napcat, `mioki 发生未捕获异常:\n\n${err?.message || "未知错误"}`);
+		});
+		process.on("unhandledRejection", async (err) => {
+			napcat.logger.error(">>> unhandledRejection, 出错了", err);
+			if (Date.now() - lastNoticeTime < 1e3) return;
+			lastNoticeTime = Date.now();
+			const date = (/* @__PURE__ */ new Date()).toLocaleString();
+			await noticeMainOwner(napcat, `【${date}】\n\nmioki 发生未处理异常:\n\n${err?.message || "未知错误"}`);
+		});
+		ensurePluginDir();
+		const plugins = botConfig.plugins.map((p) => ({
+			dirName: p,
+			absPath: node_path.default.resolve(plugin_dir, p)
+		})).filter((p) => {
+			if (!node_fs.default.existsSync(p.absPath)) {
+				napcat.logger.warn(`>>> 插件 ${p.dirName} 不存在，已忽略`);
+				return false;
+			}
+			return true;
+		});
+		const failedImportPlugins = [];
+		const promises = plugins.map(async ({ absPath, dirName }) => {
+			try {
+				const plugin = await jiti$1.import(absPath, { default: true });
+				if (plugin.name !== dirName) {
+					const tip = `>>> 插件目录名 [${dirName}] 和插件声明的 name [${plugin.name}] 不一致，可能导致重载异常，请修改一致后重启。`;
+					napcat.logger.warn(tip);
+					noticeMainOwner(napcat, tip);
+				}
+				return plugin;
+			} catch (e) {
+				const err = stringifyError(e);
+				failedImportPlugins.push([dirName, err]);
+				return null;
+			}
+		});
+		const start$1 = node_process.hrtime.bigint();
+		const sortedUserPlugins = (await Promise.all(promises)).filter(Boolean).toSorted((prev, next) => (prev.priority ?? 100) - (next.priority ?? 100));
+		if (failedImportPlugins.length) {
+			const tip = `>>> ${failedImportPlugins.length} 个插件加载失败: \n\n${failedImportPlugins.map(([dirName, err]) => `${dirName}: ${err}`).join("\n\n")}`;
+			napcat.logger.warn(tip);
+			noticeMainOwner(napcat, tip);
+		}
+		const pluginGroups = /* @__PURE__ */ new Map();
+		for (const plugin of sortedUserPlugins) {
+			const priority = plugin.priority ?? 100;
+			if (!pluginGroups.has(priority)) pluginGroups.set(priority, []);
+			pluginGroups.get(priority).push(plugin);
+		}
+		const sortedGroups = Array.from(pluginGroups.entries()).toSorted(([a], [b]) => a - b);
+		const failedEnablePlugins = [];
+		try {
+			napcat.logger.info(`>>> 加载内置插件: ${BUILTIN_PLUGINS.map((p) => p.name).join(", ")}`);
+			await Promise.all(BUILTIN_PLUGINS.map((p) => enablePlugin(napcat, p, "builtin")));
+			for (const [priority, plugins$1] of sortedGroups) {
+				napcat.logger.info(`>>> 加载优先级 ${priority} 的插件: ${plugins$1.map((p) => p.name).join(", ")}`);
+				await Promise.all(plugins$1.map(async (p) => {
+					try {
+						await enablePlugin(napcat, p, "external");
+					} catch (e) {
+						const err = stringifyError(e);
+						failedEnablePlugins.push([p.name, err]);
+					}
+				}));
+			}
+		} catch (e) {
+			napcat.logger.error(e?.message);
+			noticeMainOwner(napcat, e?.message);
+		}
+		const end = node_process.hrtime.bigint();
+		const costTime = Math.round(Number(end - start$1)) / 1e6;
+		const failedCount = failedImportPlugins.length + failedEnablePlugins.length;
+		const failedInfo = failedCount > 0 ? `${failedCount} 个失败 (导入 ${failedImportPlugins.length}，启用 ${failedImportPlugins.length})。` : "";
+		napcat.logger.info(`>>> 成功加载了 ${runtimePlugins.size} 个插件。${failedInfo ? failedInfo : ""}总耗时 ${costTime} ms`);
+		if (botConfig.online_push) await noticeMainOwner(napcat, `✅ mioki v${version} 已就绪`);
+	});
+	await napcat.run();
+}
 
 //#endregion
+exports.BOT_CWD = BOT_CWD;
+exports.ChromeUA = ChromeUA;
+exports.START_TIME = START_TIME;
+exports.addService = addService;
+exports.base64Decode = base64Decode;
+exports.base64Encode = base64Encode;
+exports.botConfig = botConfig;
+exports.clamp = clamp;
+exports.createCmd = createCmd;
+exports.createDB = createDB;
+exports.createForwardMsg = createForwardMsg;
+exports.createStore = createStore;
+Object.defineProperty(exports, 'dayjs', {
+  enumerable: true,
+  get: function () {
+    return dayjs.default;
+  }
+});
+Object.defineProperty(exports, 'dedent', {
+  enumerable: true,
+  get: function () {
+    return dedent.default;
+  }
+});
+exports.definePlugin = definePlugin;
+exports.enablePlugin = enablePlugin;
+exports.ensureBuffer = ensureBuffer;
+exports.ensurePluginDir = ensurePluginDir;
+Object.defineProperty(exports, 'filesize', {
+  enumerable: true,
+  get: function () {
+    return filesize.filesize;
+  }
+});
+exports.filter = filter;
+exports.find = find;
+exports.findLocalPlugins = findLocalPlugins;
+exports.formatDuration = formatDuration;
+exports.formatQQLevel = formatQQLevel;
+Object.defineProperty(exports, 'fs', {
+  enumerable: true,
+  get: function () {
+    return node_fs.default;
+  }
+});
+exports.getAbsPluginDir = getAbsPluginDir;
+exports.getAuthCodeViaTicket = getAuthCodeViaTicket;
+exports.getBfaceUrl = getBfaceUrl;
+exports.getGroupAvatarLink = getGroupAvatarLink;
+exports.getImage = getImage;
+exports.getImageUrl = getImageUrl;
+exports.getLogFilePath = getLogFilePath;
+exports.getMentionedImage = getMentionedImage;
+exports.getMentionedImageUrl = getMentionedImageUrl;
+exports.getMentionedUserId = getMentionedUserId;
+exports.getMinicoTokenViaAuthCode = getMinicoTokenViaAuthCode;
+exports.getMiokiLogger = getMiokiLogger;
+exports.getQQAvatarLink = getQQAvatarLink;
+exports.getQuoteImage = getQuoteImage;
+exports.getQuoteImageUrl = getQuoteImageUrl;
+exports.getQuoteMessage = getQuoteMessage;
+exports.getQuoteText = getQuoteText;
+exports.getTerminalInput = getTerminalInput;
+exports.getViolationRecords = getViolationRecords;
+exports.hasRight = hasRight;
+exports.isAdmin = isAdmin;
+exports.isBoolean = isBoolean;
+exports.isDefined = isDefined;
+exports.isFunction = isFunction;
+exports.isGroupMsg = isGroupMsg;
+exports.isInPm2 = isInPm2;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isOwner = isOwner;
+exports.isOwnerOrAdmin = isOwnerOrAdmin;
+exports.isPrivateMsg = isPrivateMsg;
+exports.isString = isString;
+exports.jiti = jiti$1;
+exports.localNum = localNum;
+exports.localeDate = localeDate;
+exports.localeTime = localeTime;
+exports.match = match;
+exports.md5 = md5;
+Object.defineProperty(exports, 'mri', {
+  enumerable: true,
+  get: function () {
+    return mri.default;
+  }
+});
+exports.noNullish = noNullish;
+exports.noticeAdmins = noticeAdmins;
+exports.noticeFriends = noticeFriends;
+exports.noticeGroups = noticeGroups;
+exports.noticeMainOwner = noticeMainOwner;
+exports.noticeOwners = noticeOwners;
+Object.defineProperty(exports, 'path', {
+  enumerable: true,
+  get: function () {
+    return node_path.default;
+  }
+});
+Object.defineProperty(exports, 'prettyMs', {
+  enumerable: true,
+  get: function () {
+    return pretty_ms.default;
+  }
+});
+exports.qs = qs;
+exports.queryDevToolsLoginStatus = queryDevToolsLoginStatus;
+exports.randomId = randomId;
+exports.randomInt = randomInt;
+exports.randomItem = randomItem;
+exports.randomItems = randomItems;
+exports.readMiokiConfig = readMiokiConfig;
+exports.readPackageJson = readPackageJson;
+exports.requestLoginViaDevTools = requestLoginViaDevTools;
+exports.runWithErrorHandler = runWithErrorHandler;
+exports.runWithReaction = runWithReaction;
+exports.runtimePlugins = runtimePlugins;
+exports.services = services;
+exports.signArk = signArk;
 exports.start = start;
+Object.defineProperty(exports, 'string2argv', {
+  enumerable: true,
+  get: function () {
+    return string2argv.string2argv;
+  }
+});
+exports.stringifyError = stringifyError;
+Object.defineProperty(exports, 'systemInfo', {
+  enumerable: true,
+  get: function () {
+    return systeminformation.default;
+  }
+});
+exports.text = text;
+exports.toArray = toArray;
+exports.toMsgId = toMsgId;
+exports.unique = unique;
+exports.updateBotCWD = updateBotCWD;
+exports.updateBotConfig = updateBotConfig;
+exports.uploadImageToCollection = uploadImageToCollection;
+exports.uploadImageToGroupHomework = uploadImageToGroupHomework;
+exports.uploadImageToGroupNotice = uploadImageToGroupNotice;
+exports.uuid = uuid;
+exports.wait = wait;
+exports.writePackageJson = writePackageJson;
 //# sourceMappingURL=index.cjs.map