koishi-plugin-bilibili-notify 3.2.4 → 3.2.5-alpha.1

package/lib/comRegister-t7UnYFig.js

@@ -0,0 +1,1426 @@
+const require_chunk = require('./chunk-CrFLpmCJ.js');
+const require_utils = require('./utils-BoaYrSvG.js');
+const require_type = require('./type-WjCy4YMc.js');
+const koishi = require_chunk.__toESM(require("koishi"));
+const qrcode = require_chunk.__toESM(require("qrcode"));
+const cron = require_chunk.__toESM(require("cron"));
+const luxon = require_chunk.__toESM(require("luxon"));
+const __satorijs_element_jsx_runtime = require_chunk.__toESM(require("@satorijs/element/jsx-runtime"));
+
+//#region node_modules/@koishijs/plugin-help/lib/index.js
+var require_lib = require_chunk.__commonJS({ "node_modules/@koishijs/plugin-help/lib/index.js"(exports, module) {
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __name = (target, value) => __defProp(target, "name", {
+		value,
+		configurable: true
+	});
+	var __export = (target, all) => {
+		for (var name2 in all) __defProp(target, name2, {
+			get: all[name2],
+			enumerable: true
+		});
+	};
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") {
+			for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: () => from[key],
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+	var src_exports = {};
+	__export(src_exports, {
+		Config: () => Config,
+		apply: () => apply,
+		name: () => name
+	});
+	module.exports = __toCommonJS(src_exports);
+	var import_koishi = require("koishi");
+	var zh_CN_default = { commands: { help: {
+		description: "显示帮助信息",
+		shortcuts: { help: "帮助" },
+		options: {
+			help: "显示此信息",
+			authority: "显示权限设置",
+			showHidden: "查看隐藏的选项和指令"
+		},
+		messages: {
+			"not-found": "指令未找到。",
+			"hint-authority": "括号内为对应的最低权限等级",
+			"hint-subcommand": "标有星号的表示含有子指令",
+			"command-title": "指令：{0}",
+			"command-aliases": "别名：{0}。",
+			"command-examples": "使用示例：",
+			"command-authority": "最低权限：{0} 级。",
+			"subcommand-prolog": "可用的子指令有{0}：",
+			"global-prolog": "当前可用的指令有{0}：",
+			"global-epilog": "输入“{0}help 指令名”查看特定指令的语法和使用示例。",
+			"available-options": "可用的选项有：",
+			"available-options-with-authority": "可用的选项有（括号内为额外要求的权限等级）："
+		}
+	} } };
+	var en_US_default = { commands: { help: {
+		description: "Show help",
+		shortcuts: { help: "<></>" },
+		options: {
+			help: "show this message",
+			authority: "show authority requirements",
+			showHidden: "show hidden options and commands"
+		},
+		messages: {
+			"not-found": "Command not found.",
+			"hint-authority": "this minimum authority is marked in parentheses",
+			"hint-subcommand": "those marked with an asterisk have subcommands",
+			"command-title": "Command: {0}",
+			"command-aliases": "Aliases: {0}.",
+			"command-examples": "Examples:",
+			"command-authority": "Minimal authority: {0}.",
+			"subcommand-prolog": "Available subcommands{0}:",
+			"global-prolog": "Available commands{0}:",
+			"global-epilog": "Type \"{0}help <command>\" to see syntax and examples for a specific command.",
+			"available-options": "Available options:",
+			"available-options-with-authority": "Available options (parentheses indicate additional authority requirement):"
+		}
+	} } };
+	var Config = import_koishi.Schema.object({
+		shortcut: import_koishi.Schema.boolean().default(true).description("是否启用快捷调用。"),
+		options: import_koishi.Schema.boolean().default(true).description("是否为每个指令添加 `-h, --help` 选项。")
+	});
+	function executeHelp(session, name2) {
+		if (!session.app.$commander.get("help")) return;
+		return session.execute({
+			name: "help",
+			args: [name2]
+		});
+	}
+	__name(executeHelp, "executeHelp");
+	var name = "help";
+	function apply(ctx, config) {
+		ctx.i18n.define("zh-CN", zh_CN_default);
+		ctx.i18n.define("en-US", en_US_default);
+		function enableHelp(command) {
+			command[import_koishi.Context.current] = ctx;
+			command.option("help", "-h", {
+				hidden: true,
+				notUsage: true,
+				descPath: "commands.help.options.help"
+			});
+		}
+		__name(enableHelp, "enableHelp");
+		ctx.schema.extend("command", import_koishi.Schema.object({
+			hideOptions: import_koishi.Schema.boolean().description("是否隐藏所有选项。").default(false).hidden(),
+			hidden: import_koishi.Schema.computed(import_koishi.Schema.boolean()).description("在帮助菜单中隐藏指令。").default(false),
+			params: import_koishi.Schema.any().description("帮助信息的本地化参数。").hidden()
+		}), 900);
+		ctx.schema.extend("command-option", import_koishi.Schema.object({
+			hidden: import_koishi.Schema.computed(import_koishi.Schema.boolean()).description("在帮助菜单中隐藏选项。").default(false),
+			params: import_koishi.Schema.any().description("帮助信息的本地化参数。").hidden()
+		}), 900);
+		if (config.options !== false) {
+			ctx.$commander._commandList.forEach(enableHelp);
+			ctx.on("command-added", enableHelp);
+		}
+		ctx.before("command/execute", (argv) => {
+			const { command, options, session } = argv;
+			if (options["help"] && command._options.help) return executeHelp(session, command.name);
+			if (command["_actions"].length) return;
+			return executeHelp(session, command.name);
+		});
+		const $ = ctx.$commander;
+		function findCommand(target, session) {
+			const command = $.resolve(target, session);
+			if (command?.ctx.filter(session)) return command;
+			const data = ctx.i18n.find("commands.(name).shortcuts.(variant)", target).map((item) => ({
+				...item,
+				command: $.resolve(item.data.name, session)
+			})).filter((item) => item.command?.match(session));
+			const perfect = data.filter((item) => item.similarity === 1);
+			if (!perfect.length) return data;
+			return perfect[0].command;
+		}
+		__name(findCommand, "findCommand");
+		const createCollector = /* @__PURE__ */ __name((key) => (argv, fields) => {
+			const { args: [target], session } = argv;
+			const result = findCommand(target, session);
+			if (!Array.isArray(result)) {
+				session.collect(key, {
+					...argv,
+					command: result,
+					args: [],
+					options: { help: true }
+				}, fields);
+				return;
+			}
+			for (const { command } of result) session.collect(key, {
+				...argv,
+				command,
+				args: [],
+				options: { help: true }
+			}, fields);
+		}, "createCollector");
+		async function inferCommand(target, session) {
+			const result = findCommand(target, session);
+			if (!Array.isArray(result)) return result;
+			const expect = $.available(session).filter((name3) => {
+				return name3 && session.app.i18n.compare(name3, target);
+			});
+			for (const item of result) {
+				if (expect.includes(item.data.name)) continue;
+				expect.push(item.data.name);
+			}
+			const cache = /* @__PURE__ */ new Map();
+			const name2 = await session.suggest({
+				expect,
+				prefix: session.text(".not-found"),
+				suffix: session.text("internal.suggest-command"),
+				filter: /* @__PURE__ */ __name((name3) => {
+					const command = $.resolve(name3, session);
+					if (!command) return false;
+					return ctx.permissions.test(`command:${command.name}`, session, cache);
+				}, "filter")
+			});
+			return $.resolve(name2, session);
+		}
+		__name(inferCommand, "inferCommand");
+		const cmd = ctx.command("help [command:string]", {
+			authority: 0,
+			...config
+		}).userFields(["authority"]).userFields(createCollector("user")).channelFields(createCollector("channel")).option("showHidden", "-H").action(async ({ session, options }, target) => {
+			if (!target) {
+				const prefix = session.resolve(session.app.koishi.config.prefix)[0] ?? "";
+				const commands = $._commandList.filter((cmd2) => cmd2.parent === null);
+				const output = await formatCommands(".global-prolog", session, commands, options);
+				const epilog = session.text(".global-epilog", [prefix]);
+				if (epilog) output.push(epilog);
+				return output.filter(Boolean).join("\n");
+			}
+			const command = await inferCommand(target, session);
+			if (!command) return;
+			if (!await ctx.permissions.test(`command:${command.name}`, session)) return session.text("internal.low-authority");
+			return showHelp(command, session, options);
+		});
+		if (config.shortcut !== false) cmd.shortcut("help", {
+			i18n: true,
+			fuzzy: true
+		});
+	}
+	__name(apply, "apply");
+	function* getCommands(session, commands, showHidden = false) {
+		for (const command of commands) {
+			if (!showHidden && session.resolve(command.config.hidden)) continue;
+			if (command.match(session) && Object.keys(command._aliases).length) yield command;
+			else yield* getCommands(session, command.children, showHidden);
+		}
+	}
+	__name(getCommands, "getCommands");
+	async function formatCommands(path, session, children, options) {
+		const cache = /* @__PURE__ */ new Map();
+		children = Array.from(getCommands(session, children, options.showHidden));
+		children = (await Promise.all(children.map(async (command) => {
+			return [command, await session.app.permissions.test(`command:${command.name}`, session, cache)];
+		}))).filter(([, result]) => result).map(([command]) => command);
+		children.sort((a, b) => a.displayName > b.displayName ? 1 : -1);
+		if (!children.length) return [];
+		const prefix = session.resolve(session.app.koishi.config.prefix)[0] ?? "";
+		const output = children.map(({ name: name2, displayName, config }) => {
+			let output2 = "    " + prefix + displayName.replace(/\./g, " ");
+			output2 += "  " + session.text([`commands.${name2}.description`, ""], config.params);
+			return output2;
+		});
+		const hints = [];
+		const hintText = hints.length ? session.text("general.paren", [hints.join(session.text("general.comma"))]) : "";
+		output.unshift(session.text(path, [hintText]));
+		return output;
+	}
+	__name(formatCommands, "formatCommands");
+	function getOptionVisibility(option, session) {
+		if (session.user && option.authority > session.user.authority) return false;
+		return !session.resolve(option.hidden);
+	}
+	__name(getOptionVisibility, "getOptionVisibility");
+	function getOptions(command, session, config) {
+		if (command.config.hideOptions && !config.showHidden) return [];
+		const options = config.showHidden ? Object.values(command._options) : Object.values(command._options).filter((option) => getOptionVisibility(option, session));
+		if (!options.length) return [];
+		const output = [];
+		Object.values(command._options).forEach((option) => {
+			function pushOption(option2, name2) {
+				if (!config.showHidden && !getOptionVisibility(option2, session)) return;
+				let line = `${import_koishi.h.escape(option2.syntax)}`;
+				const description = session.text(option2.descPath ?? [`commands.${command.name}.options.${name2}`, ""], option2.params);
+				if (description) line += "  " + description;
+				line = command.ctx.chain("help/option", line, option2, command, session);
+				output.push("    " + line);
+			}
+			__name(pushOption, "pushOption");
+			if (!("value" in option)) pushOption(option, option.name);
+			for (const value in option.variants) pushOption(option.variants[value], `${option.name}.${value}`);
+		});
+		if (!output.length) return [];
+		output.unshift(session.text(".available-options"));
+		return output;
+	}
+	__name(getOptions, "getOptions");
+	async function showHelp(command, session, config) {
+		const output = [session.text(".command-title", [command.displayName.replace(/\./g, " ") + command.declaration])];
+		const description = session.text([`commands.${command.name}.description`, ""], command.config.params);
+		if (description) output.push(description);
+		if (session.app.database) {
+			const argv = {
+				command,
+				args: [],
+				options: { help: true }
+			};
+			const userFields = session.collect("user", argv);
+			await session.observeUser(userFields);
+			if (!session.isDirect) {
+				const channelFields = session.collect("channel", argv);
+				await session.observeChannel(channelFields);
+			}
+		}
+		if (Object.keys(command._aliases).length > 1) output.push(session.text(".command-aliases", [Array.from(Object.keys(command._aliases).slice(1)).join("，")]));
+		session.app.emit(session, "help/command", output, command, session);
+		if (command._usage) output.push(typeof command._usage === "string" ? command._usage : await command._usage(session));
+		else {
+			const text = session.text([`commands.${command.name}.usage`, ""], command.config.params);
+			if (text) output.push(text);
+		}
+		output.push(...getOptions(command, session, config));
+		if (command._examples.length) output.push(session.text(".command-examples"), ...command._examples.map((example) => "    " + example));
+		else {
+			const text = session.text([`commands.${command.name}.examples`, ""], command.config.params);
+			if (text) output.push(...text.split("\n").map((line) => "    " + line));
+		}
+		output.push(...await formatCommands(".subcommand-prolog", session, command.children, config));
+		return output.filter(Boolean).join("\n");
+	}
+	__name(showHelp, "showHelp");
+} });
+
+//#endregion
+//#region src/comRegister.tsx
+var import_lib = require_chunk.__toESM(require_lib());
+var ComRegister = class {
+	static inject = [
+		"ba",
+		"gi",
+		"database",
+		"bl",
+		"sm"
+	];
+	qqRelatedBotList = [
+		"qq",
+		"onebot",
+		"red",
+		"satori",
+		"chronocat"
+	];
+	logger;
+	config;
+	loginTimer;
+	num = 0;
+	rebootCount = 0;
+	subNotifier;
+	ctx;
+	subManager = [];
+	dynamicTimelineManager = /* @__PURE__ */ new Map();
+	liveStatusManager = /* @__PURE__ */ new Map();
+	loginDBData;
+	privateBot;
+	dynamicJob;
+	liveJob;
+	constructor(ctx, config) {
+		this.ctx = ctx;
+		this.init(config);
+		const statusCom = ctx.command("status", "插件状态相关指令", { permissions: ["authority:5"] });
+		statusCom.subcommand(".dyn", "查看动态监测运行状态").usage("查看动态监测运行状态").example("status dyn").action(() => {
+			if (this.dynamicJob?.isActive) return "动态监测正在运行";
+			return "动态监测未运行";
+		});
+		statusCom.subcommand(".sm", "查看订阅管理对象").usage("查看订阅管理对象").example("status sm").action(async () => {
+			this.logger.info(this.subManager);
+			return "查看控制台";
+		});
+		statusCom.subcommand(".bot", "查询当前拥有的机器人信息", { hidden: true }).usage("查询当前拥有的机器人信息").example("status bot 查询当前拥有的机器人信息").action(() => {
+			this.logger.info("开始输出BOT信息");
+			for (const bot of ctx.bots) {
+				this.logger.info("--------------------------------");
+				this.logger.info(`平台：${bot.platform}`);
+				this.logger.info(`名称：${bot.user.name}`);
+				this.logger.info("--------------------------------");
+			}
+		});
+		statusCom.subcommand(".env", "查询当前环境的信息", { hidden: true }).usage("查询当前环境的信息").example("status env 查询当前环境的信息").action(async ({ session }) => {
+			await session.send(`Guild ID:${session.event.guild.id}`);
+			await session.send(`Channel ID: ${session.event.channel.id}`);
+		});
+		const biliCom = ctx.command("bili", "bili-notify插件相关指令", { permissions: ["authority:3"] });
+		biliCom.subcommand(".login", "登录B站之后才可以进行之后的操作").usage("使用二维码登录，登录B站之后才可以进行之后的操作").example("bili login").action(async ({ session }) => {
+			this.logger.info("调用bili login指令");
+			let content;
+			try {
+				content = await ctx.ba.getLoginQRCode();
+			} catch (e) {
+				return "bili login getLoginQRCode() 本次网络请求失败";
+			}
+			if (content.code !== 0) return await session.send("出问题咯，请联系管理员解决");
+			qrcode.default.toBuffer(content.data.url, {
+				errorCorrectionLevel: "H",
+				type: "png",
+				margin: 1,
+				color: {
+					dark: "#000000",
+					light: "#FFFFFF"
+				}
+			}, async (err, buffer) => {
+				if (err) return await session.send("二维码生成出错，请重新尝试");
+				await session.send(koishi.h.image(buffer, "image/jpeg"));
+			});
+			if (this.loginTimer) this.loginTimer();
+			let flag = true;
+			this.loginTimer = ctx.setInterval(async () => {
+				try {
+					if (!flag) return;
+					flag = false;
+					let loginContent;
+					try {
+						loginContent = await ctx.ba.getLoginStatus(content.data.qrcode_key);
+					} catch (e) {
+						this.logger.error(e);
+						return;
+					}
+					if (loginContent.code !== 0) {
+						this.loginTimer();
+						return await session.send("登录失败请重试");
+					}
+					if (loginContent.data.code === 86038) {
+						this.loginTimer();
+						return await session.send("二维码已失效，请重新登录");
+					}
+					if (loginContent.data.code === 0) {
+						const encryptedCookies = ctx.ba.encrypt(ctx.ba.getCookies());
+						const encryptedRefreshToken = ctx.ba.encrypt(loginContent.data.refresh_token);
+						await ctx.database.upsert("loginBili", [{
+							id: 1,
+							bili_cookies: encryptedCookies,
+							bili_refresh_token: encryptedRefreshToken
+						}]);
+						this.loginDBData = (await this.ctx.database.get("loginBili", 1, ["dynamic_group_id"]))[0];
+						await this.ctx.ba.loadCookiesFromDatabase();
+						await this.checkIfLoginInfoIsLoaded();
+						this.loginTimer();
+						const { code, msg } = await this.loadSubFromConfig(config.sub);
+						if (code !== 0) this.logger.error(msg);
+						ctx.ba.disposeNotifier();
+						await session.send("登录成功");
+						await session.execute("bili list");
+						ctx.ba.enableRefreshCookiesDetect();
+					}
+				} finally {
+					flag = true;
+				}
+			}, 1e3);
+		});
+		biliCom.subcommand(".list", "展示订阅对象").usage("展示订阅对象").example("bili list").action(() => {
+			const subTable = this.subShow();
+			return subTable;
+		});
+		biliCom.subcommand(".private", "向主人账号发送一条测试消息", { hidden: true }).usage("向主人账号发送一条测试消息").example("bili private 向主人账号发送一条测试消息").action(async ({ session }) => {
+			await this.sendPrivateMsg("Hello World");
+			await session.send("已发送消息，如未收到则说明您的机器人不支持发送私聊消息或您的信息填写有误");
+		});
+		biliCom.subcommand(".ll").usage("展示当前正在直播的订阅对象").example("bili ll").action(async () => {
+			const { data: { live_users } } = await ctx.ba.getTheUserWhoIsLiveStreaming();
+			const subLiveUsers = [];
+			for (const sub of this.subManager) {
+				let onLive = false;
+				if (live_users.items) {
+					for (const user of live_users.items) if (user.mid.toString() === sub.uid && sub.live) {
+						onLive = true;
+						break;
+					}
+				}
+				subLiveUsers.push({
+					uid: Number.parseInt(sub.uid),
+					uname: sub.uname,
+					onLive
+				});
+			}
+			let table = "";
+			for (const user of subLiveUsers) table += `[UID:${user.uid}] 「${user.uname}」 ${user.onLive ? "正在直播" : "未开播"}\n`;
+			return table;
+		});
+		biliCom.subcommand(".dyn <uid:string> [index:number]", "手动推送一条动态信息", { hidden: true }).usage("手动推送一条动态信息").example("bili dyn 233 1 手动推送UID为233用户空间的第一条动态信息").action(async ({ session }, uid, index) => {
+			const i = index && index - 1 || 0;
+			const content = await this.ctx.ba.getUserSpaceDynamic(uid);
+			const item = content.data.items[i];
+			const buffer = await require_utils.withRetry(async () => {
+				return await this.ctx.gi.generateDynamicImg(item);
+			}, 1).catch(async (e) => {
+				if (e.message === "直播开播动态，不做处理") {
+					await session.send("直播开播动态，不做处理");
+					return;
+				}
+				if (e.message === "出现关键词，屏蔽该动态") {
+					await session.send("已屏蔽该动态");
+					return;
+				}
+				if (e.message === "已屏蔽转发动态") {
+					await session.send("已屏蔽转发动态");
+					return;
+				}
+				if (e.message === "已屏蔽专栏动态") {
+					await session.send("已屏蔽专栏动态");
+					return;
+				}
+				this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
+			});
+			buffer && await session.send(koishi.h.image(buffer, "image/jpeg"));
+		});
+	}
+	async init(config) {
+		this.logger = this.ctx.logger("cr");
+		this.logger.info("初始化插件中...");
+		this.config = config;
+		this.privateBot = this.ctx.bots.find((bot) => bot.platform === config.master.platform);
+		if (!this.privateBot) this.ctx.notifier.create({ content: "您未配置私人机器人，将无法向您推送机器人状态！" });
+		this.loginDBData = (await this.ctx.database.get("loginBili", 1, ["dynamic_group_id"]))[0];
+		await this.checkIfLoginInfoIsLoaded();
+		if (!await this.checkIfIsLogin()) {
+			this.logger.info("账号未登录，请登录");
+			return;
+		}
+		if (config.sub) {
+			const { code, msg } = await this.loadSubFromConfig(config.sub);
+			if (code !== 0) {
+				this.logger.error(msg);
+				this.logger.error("订阅对象加载失败，插件初始化失败！");
+				await this.sendPrivateMsg("订阅对象加载失败，插件初始化失败！");
+				return;
+			}
+		}
+		this.initManager();
+		this.checkIfDynamicDetectIsNeeded();
+		this.checkIfLiveDetectIsNeeded();
+		this.updateSubNotifier();
+		this.ctx.on("dispose", () => {
+			if (this.loginTimer) this.loginTimer();
+			if (this.dynamicJob) this.dynamicJob.stop();
+			if (this.liveJob) this.liveJob.stop();
+		});
+		this.logger.info("插件初始化完毕！");
+	}
+	initManager() {
+		for (const sub of this.subManager) {
+			if (sub.dynamic) this.dynamicTimelineManager.set(sub.uid, Math.floor(luxon.DateTime.now().toSeconds()));
+			if (sub.live) this.liveStatusManager.set(sub.uid, {
+				roomId: sub.roomId,
+				live: false,
+				liveRoomInfo: void 0,
+				masterInfo: void 0,
+				watchedNum: "0",
+				liveStartTime: "",
+				liveStartTimeInit: false,
+				push: 0
+			});
+		}
+	}
+	getBot(pf, selfId) {
+		if (!selfId || selfId === "") return this.ctx.bots.find((bot) => bot.platform === pf);
+		return this.ctx.bots.find((bot) => bot.platform === pf && bot.selfId === selfId);
+	}
+	async sendPrivateMsg(content) {
+		if (this.config.master.enable) if (this.config.master.masterAccountGuildId) await this.privateBot.sendPrivateMessage(this.config.master.masterAccount, content, this.config.master.masterAccountGuildId);
+		else await this.privateBot.sendPrivateMessage(this.config.master.masterAccount, content);
+	}
+	async sendPrivateMsgAndRebootService() {
+		if (this.rebootCount >= 3) {
+			this.logger.error("已重启插件三次，请检查机器人状态后使用指令 sys start 启动插件");
+			await this.sendPrivateMsg("已重启插件三次，请检查机器人状态后使用指令 sys start 启动插件");
+			await this.ctx.sm.disposePlugin();
+			return;
+		}
+		this.rebootCount++;
+		this.logger.info("插件出现未知错误，正在重启插件");
+		const flag = await this.ctx.sm.restartPlugin();
+		if (flag) this.logger.info("重启插件成功");
+		else {
+			this.logger.error("重启插件失败，请检查机器人状态后使用指令 sys start 启动插件");
+			await this.sendPrivateMsg("重启插件失败，请检查机器人状态后使用指令 sys start 启动插件");
+			await this.ctx.sm.disposePlugin();
+		}
+	}
+	async sendPrivateMsgAndStopService() {
+		await this.sendPrivateMsg("插件发生未知错误，请检查机器人状态后使用指令 sys start 启动插件");
+		this.logger.error("插件发生未知错误，请检查机器人状态后使用指令 sys start 启动插件");
+		await this.ctx.sm.disposePlugin();
+		return;
+	}
+	async sendMessageWithRetry(bot, channelId, content) {
+		require_utils.withRetry(async () => await bot.sendMessage(channelId, content), 1).catch(async (e) => {
+			if (e.message === "this._request is not a function") {
+				this.ctx.setTimeout(async () => {
+					await this.sendMessageWithRetry(bot, channelId, content);
+				}, 2e3);
+				return;
+			}
+			this.logger.error(`发送群组ID:${channelId}消息失败！原因: ${e.message}`);
+			await this.sendPrivateMsg(`发送群组ID:${channelId}消息失败，请查看日志`);
+		});
+	}
+	getGroupsThatMeetCriteria(targets, type) {
+		const pushArr = [];
+		if (type === require_type.PushType.Live || type === require_type.PushType.StartBroadcasting) {
+			for (const target of targets) for (const channel of target.channelArr) if (channel.live) pushArr.push(`${target.platform}:${channel.channelId}`);
+			return pushArr;
+		}
+		if (type === require_type.PushType.Dynamic) {
+			for (const target of targets) for (const channel of target.channelArr) if (channel.dynamic) pushArr.push(`${target.platform}:${channel.channelId}`);
+			return pushArr;
+		}
+		if (type === require_type.PushType.LiveGuardBuy) {
+			for (const target of targets) for (const channel of target.channelArr) if (channel.liveGuardBuy) pushArr.push(`${target.platform}:${channel.channelId}`);
+			return pushArr;
+		}
+	}
+	async broadcastToTargets(targets, content, type) {
+		if (targets.length !== 1 || targets[0].channelArr.length !== 1) {
+			const pushArr = this.getGroupsThatMeetCriteria(targets, type);
+			this.logger.info(`推送消息到 ${pushArr.length} 个目标频道，目标频道为：${pushArr.join(", ")}`);
+			await require_utils.withRetry(async () => {
+				await this.ctx.broadcast(pushArr, content);
+			}, 1);
+			return;
+		}
+		const targetChannel = targets[0].channelArr[0];
+		const bot = this.getBot(targets[0].platform, targetChannel.bot);
+		if (!bot || !bot.isActive) {
+			this.sendPrivateMsg("未找到对应bot实例，本次消息推送取消！");
+			this.logger.warn("未找到对应bot实例，本次消息推送取消！");
+			return;
+		}
+		const pushTypePatternMatching = {
+			[require_type.PushType.Live]: async () => {
+				if (targetChannel.live) await this.sendMessageWithRetry(bot, targetChannel.channelId, content);
+			},
+			[require_type.PushType.Dynamic]: async () => {
+				if (targetChannel.dynamic) await this.sendMessageWithRetry(bot, targetChannel.channelId, content);
+			},
+			[require_type.PushType.StartBroadcasting]: async () => {
+				if (targetChannel.live) await this.sendMessageWithRetry(bot, targetChannel.channelId, content);
+				if (targetChannel.atAll) await this.sendMessageWithRetry(bot, targetChannel.channelId, /* @__PURE__ */ (0, __satorijs_element_jsx_runtime.jsx)("at", { type: "all" }));
+			},
+			[require_type.PushType.LiveGuardBuy]: async () => {
+				if (targetChannel.liveGuardBuy) await this.sendMessageWithRetry(bot, targetChannel.channelId, content);
+			}
+		};
+		await pushTypePatternMatching[type]();
+	}
+	dynamicDetect() {
+		const handler = async () => {
+			const currentPushDyn = {};
+			const content = await require_utils.withRetry(async () => {
+				return await this.ctx.ba.getAllDynamic();
+			}, 1).catch((e) => {
+				this.logger.error(`dynamicDetect getAllDynamic() 发生了错误，错误为：${e.message}`);
+			});
+			if (!content) return;
+			if (content.code !== 0) switch (content.code) {
+				case -101: {
+					this.logger.error("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
+					await this.sendPrivateMsg("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
+					await this.ctx.sm.disposePlugin();
+					break;
+				}
+				case -352: {
+					this.logger.error("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
+					await this.sendPrivateMsg("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
+					await this.ctx.sm.disposePlugin();
+					break;
+				}
+				case 4101128:
+				case 4101129: {
+					this.logger.error(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`);
+					await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`);
+					break;
+				}
+				default: {
+					await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`);
+					break;
+				}
+			}
+			const items = content.data.items;
+			for (const item of items) {
+				if (!item) continue;
+				const postTime = item.modules.module_author.pub_ts;
+				const uid = item.modules.module_author.mid.toString();
+				const name$1 = item.modules.module_author.name;
+				if (this.dynamicTimelineManager.has(uid)) {
+					const timeline = this.dynamicTimelineManager.get(uid);
+					if (timeline < postTime) {
+						const sub = this.subManager.find((sub$1) => sub$1.uid === uid);
+						const buffer = await require_utils.withRetry(async () => {
+							return await this.ctx.gi.generateDynamicImg(item, sub.card.enable ? sub.card : void 0);
+						}, 1).catch(async (e) => {
+							if (e.message === "直播开播动态，不做处理") return;
+							if (e.message === "出现关键词，屏蔽该动态") {
+								if (this.config.filter.notify) await this.broadcastToTargets(sub.target, `${name$1}发布了一条含有屏蔽关键字的动态`, require_type.PushType.Dynamic);
+								return;
+							}
+							if (e.message === "已屏蔽转发动态") {
+								if (this.config.filter.notify) await this.broadcastToTargets(sub.target, `${name$1}转发了一条动态，已屏蔽`, require_type.PushType.Dynamic);
+								return;
+							}
+							if (e.message === "已屏蔽专栏动态") {
+								if (this.config.filter.notify) await this.broadcastToTargets(sub.target, `${name$1}投稿了一条专栏，已屏蔽`, require_type.PushType.Dynamic);
+								return;
+							}
+							this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
+							await this.sendPrivateMsgAndStopService();
+						});
+						if (!buffer) continue;
+						let dUrl = "";
+						if (this.config.dynamicUrl) if (item.type === "DYNAMIC_TYPE_AV") if (this.config.dynamicVideoUrlToBV) {
+							const bv = item.modules.module_dynamic.major.archive.jump_url.match(/BV[0-9A-Za-z]+/);
+							dUrl = bv ? bv[0] : "";
+						} else dUrl = `${name$1}发布了新视频：https:${item.modules.module_dynamic.major.archive.jump_url}`;
+						else dUrl = `${name$1}发布了一条动态：https://t.bilibili.com/${item.id_str}`;
+						this.logger.info("推送动态中...");
+						await this.broadcastToTargets(sub.target, /* @__PURE__ */ (0, __satorijs_element_jsx_runtime.jsxs)(__satorijs_element_jsx_runtime.Fragment, { children: [koishi.h.image(buffer, "image/jpeg"), dUrl] }), require_type.PushType.Dynamic);
+						if (this.config.pushImgsInDynamic) {
+							if (item.type === "DYNAMIC_TYPE_DRAW") {
+								const pics = item.modules?.module_dynamic?.major?.opus?.pics;
+								if (pics) {
+									const picsMsg = /* @__PURE__ */ (0, __satorijs_element_jsx_runtime.jsx)("message", {
+										forward: true,
+										children: pics.map((pic) => /* @__PURE__ */ (0, __satorijs_element_jsx_runtime.jsx)("img", {
+											src: pic.url,
+											alt: "动态图片"
+										}, pic.url))
+									});
+									await this.broadcastToTargets(sub.target, picsMsg, require_type.PushType.Dynamic);
+								}
+							}
+						}
+						if (!currentPushDyn[uid]) currentPushDyn[uid] = item;
+						this.logger.info("动态推送完毕！");
+					}
+				}
+			}
+			for (const uid in currentPushDyn) {
+				const postTime = currentPushDyn[uid].modules.module_author.pub_ts;
+				this.dynamicTimelineManager.set(uid, postTime);
+			}
+		};
+		return require_utils.withLock(handler);
+	}
+	debug_dynamicDetect() {
+		const handler = async () => {
+			const currentPushDyn = {};
+			this.logger.info("开始获取动态信息...");
+			const content = await require_utils.withRetry(async () => {
+				return await this.ctx.ba.getAllDynamic();
+			}, 1).catch((e) => {
+				this.logger.error(`dynamicDetect getAllDynamic() 发生了错误，错误为：${e.message}`);
+			});
+			if (!content) return;
+			if (content.code !== 0) switch (content.code) {
+				case -101: {
+					this.logger.error("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
+					await this.sendPrivateMsg("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
+					await this.ctx.sm.disposePlugin();
+					break;
+				}
+				case -352: {
+					this.logger.error("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
+					await this.sendPrivateMsg("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
+					await this.ctx.sm.disposePlugin();
+					break;
+				}
+				case 4101128:
+				case 4101129: {
+					this.logger.error(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`);
+					await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`);
+					break;
+				}
+				default: {
+					await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`);
+					break;
+				}
+			}
+			this.logger.info("获取动态信息成功！开始处理动态信息...");
+			const items = content.data.items;
+			for (const item of items) {
+				if (!item) continue;
+				const postTime = item.modules.module_author.pub_ts;
+				const uid = item.modules.module_author.mid.toString();
+				const name$1 = item.modules.module_author.name;
+				this.logger.info(`获取到动态信息，UP主：${name$1}，UID：${uid}，动态发布时间：${luxon.DateTime.fromSeconds(postTime).toFormat("yyyy-MM-dd HH:mm:ss")}`);
+				if (this.dynamicTimelineManager.has(uid)) {
+					this.logger.info("订阅该UP主，判断动态时间线...");
+					const timeline = this.dynamicTimelineManager.get(uid);
+					this.logger.info(`上次推送时间线：${luxon.DateTime.fromSeconds(timeline).toFormat("yyyy-MM-dd HH:mm:ss")}`);
+					if (timeline < postTime) {
+						this.logger.info("需要推送该条动态，开始推送...");
+						const sub = this.subManager.find((sub$1) => sub$1.uid === uid);
+						this.logger.info("开始渲染推送卡片...");
+						const buffer = await require_utils.withRetry(async () => {
+							return await this.ctx.gi.generateDynamicImg(item, sub.card.enable ? sub.card : void 0);
+						}, 1).catch(async (e) => {
+							if (e.message === "直播开播动态，不做处理") return;
+							if (e.message === "出现关键词，屏蔽该动态") {
+								if (this.config.filter.notify) await this.broadcastToTargets(sub.target, `${name$1}发布了一条含有屏蔽关键字的动态`, require_type.PushType.Dynamic);
+								return;
+							}
+							if (e.message === "已屏蔽转发动态") {
+								if (this.config.filter.notify) await this.broadcastToTargets(sub.target, `${name$1}转发了一条动态，已屏蔽`, require_type.PushType.Dynamic);
+								return;
+							}
+							if (e.message === "已屏蔽专栏动态") {
+								if (this.config.filter.notify) await this.broadcastToTargets(sub.target, `${name$1}投稿了一条专栏，已屏蔽`, require_type.PushType.Dynamic);
+								return;
+							}
+							this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
+							await this.sendPrivateMsgAndStopService();
+						});
+						if (!buffer) continue;
+						this.logger.info("渲染推送卡片成功！");
+						let dUrl = "";
+						if (this.config.dynamicUrl) {
+							this.logger.info("需要发送动态链接，开始生成链接...");
+							if (item.type === "DYNAMIC_TYPE_AV") if (this.config.dynamicVideoUrlToBV) {
+								const bv = item.modules.module_dynamic.major.archive.jump_url.match(/BV[0-9A-Za-z]+/);
+								dUrl = bv ? bv[0] : "";
+							} else dUrl = `${name$1}发布了新视频：https:${item.modules.module_dynamic.major.archive.jump_url}`;
+							else dUrl = `${name$1}发布了一条动态：https://t.bilibili.com/${item.id_str}`;
+							this.logger.info("动态链接生成成功！");
+						}
+						this.logger.info("推送动态中...");
+						await this.broadcastToTargets(sub.target, /* @__PURE__ */ (0, __satorijs_element_jsx_runtime.jsxs)(__satorijs_element_jsx_runtime.Fragment, { children: [koishi.h.image(buffer, "image/jpeg"), dUrl] }), require_type.PushType.Dynamic);
+						if (this.config.pushImgsInDynamic) {
+							this.logger.info("需要发送动态中的图片，开始发送...");
+							if (item.type === "DYNAMIC_TYPE_DRAW") {
+								const pics = item.modules?.module_dynamic?.major?.opus?.pics;
+								if (pics) {
+									const picsMsg = /* @__PURE__ */ (0, __satorijs_element_jsx_runtime.jsx)("message", {
+										forward: true,
+										children: pics.map((pic) => /* @__PURE__ */ (0, __satorijs_element_jsx_runtime.jsx)("img", {
+											src: pic.url,
+											alt: "动态图片"
+										}, pic.url))
+									});
+									await this.broadcastToTargets(sub.target, picsMsg, require_type.PushType.Dynamic);
+								}
+							}
+							this.logger.info("动态中的图片发送完毕！");
+						}
+						if (!currentPushDyn[uid]) currentPushDyn[uid] = item;
+						this.logger.info("动态推送完毕！");
+					}
+				}
+			}
+			this.logger.info("动态信息处理完毕！");
+			for (const uid in currentPushDyn) {
+				const postTime = currentPushDyn[uid].modules.module_author.pub_ts;
+				this.dynamicTimelineManager.set(uid, postTime);
+				this.logger.info(`更新时间线成功，UP主：${uid}，时间线：${luxon.DateTime.fromSeconds(postTime).toFormat("yyyy-MM-dd HH:mm:ss")}`);
+			}
+			this.logger.info(`本次推送动态数量：${Object.keys(currentPushDyn).length}`);
+		};
+		return require_utils.withLock(handler);
+	}
+	async useMasterInfo(uid, masterInfo, liveType) {
+		const { data } = await this.ctx.ba.getMasterInfo(uid);
+		let liveOpenFollowerNum;
+		let liveEndFollowerNum;
+		let liveFollowerChange;
+		if (liveType === require_type.LiveType.StartBroadcasting || liveType === require_type.LiveType.FirstLiveBroadcast) {
+			liveOpenFollowerNum = data.follower_num;
+			liveEndFollowerNum = data.follower_num;
+			liveFollowerChange = 0;
+		}
+		if (liveType === require_type.LiveType.StopBroadcast || liveType === require_type.LiveType.LiveBroadcast) {
+			liveOpenFollowerNum = masterInfo.liveOpenFollowerNum;
+			liveEndFollowerNum = data.follower_num;
+			liveFollowerChange = liveEndFollowerNum - masterInfo.liveOpenFollowerNum;
+		}
+		return {
+			username: data.info.uname,
+			userface: data.info.face,
+			roomId: data.room_id,
+			liveOpenFollowerNum,
+			liveEndFollowerNum,
+			liveFollowerChange
+		};
+	}
+	async useLiveRoomInfo(roomId) {
+		const data = await require_utils.withRetry(async () => await this.ctx.ba.getLiveRoomInfo(roomId)).then((content) => content.data).catch((e) => {
+			this.logger.error(`liveDetect getLiveRoomInfo 发生了错误，错误为：${e.message}`);
+			return false;
+		});
+		if (!data) return await this.sendPrivateMsgAndStopService();
+		return data;
+	}
+	async sendLiveNotifyCard(liveType, followerDisplay, liveInfo, target, liveNotifyMsg) {
+		const buffer = await require_utils.withRetry(async () => {
+			return await this.ctx.gi.generateLiveImg(liveInfo.liveRoomInfo, liveInfo.masterInfo.username, liveInfo.masterInfo.userface, followerDisplay, liveType, liveInfo.cardStyle.enable ? liveInfo.cardStyle : void 0);
+		}, 1).catch((e) => {
+			this.logger.error(`liveDetect generateLiveImg() 推送卡片生成失败，原因：${e.message}`);
+		});
+		if (!buffer) return await this.sendPrivateMsgAndStopService();
+		const msg = /* @__PURE__ */ (0, __satorijs_element_jsx_runtime.jsxs)(__satorijs_element_jsx_runtime.Fragment, { children: [koishi.h.image(buffer, "image/jpeg"), liveNotifyMsg || ""] });
+		return await this.broadcastToTargets(target, msg, liveType === require_type.LiveType.StartBroadcasting ? require_type.PushType.StartBroadcasting : require_type.PushType.Live);
+	}
+	async liveDetectWithListener(roomId, target, cardStyle) {
+		let liveTime;
+		let pushAtTimeTimer;
+		const currentLiveDanmakuArr = [];
+		let liveStatus = false;
+		let channelArrLen = 0;
+		let liveRoomInfo;
+		let masterInfo;
+		let watchedNum;
+		const liveGuardBuyPushTargetArr = target.map((channel) => {
+			const liveGuardBuyArr = channel.channelArr.filter((channelId) => channelId.liveGuardBuy);
+			channelArrLen += liveGuardBuyArr.length;
+			return {
+				channelArr: liveGuardBuyArr,
+				platform: channel.platform
+			};
+		});
+		const pushAtTimeFunc = async () => {
+			if (!await useMasterAndLiveRoomInfo(require_type.LiveType.LiveBroadcast)) {
+				await this.sendPrivateMsg("获取直播间信息失败，推送直播卡片失败！");
+				return await this.sendPrivateMsgAndStopService();
+			}
+			if (liveRoomInfo.live_status === 0 || liveRoomInfo.live_status === 2) {
+				liveStatus = false;
+				pushAtTimeTimer?.();
+				await this.sendPrivateMsg("直播间已下播！与直播间的连接可能已断开，请使用指令 sys restart 重启插件");
+				return;
+			}
+			liveTime = liveRoomInfo.live_time;
+			const watched = watchedNum || "暂未获取到";
+			const liveMsg = this.config.customLive ? this.config.customLive.replace("-name", masterInfo.username).replace("-time", await this.ctx.gi.getTimeDifference(liveTime)).replace("-watched", watched).replace("\\n", "\n").replace("-link", `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`) : null;
+			await this.sendLiveNotifyCard(require_type.LiveType.LiveBroadcast, watched, {
+				liveRoomInfo,
+				masterInfo,
+				cardStyle
+			}, target, liveMsg);
+		};
+		const useMasterAndLiveRoomInfo = async (liveType) => {
+			let flag = true;
+			liveRoomInfo = await this.useLiveRoomInfo(roomId).catch(() => {
+				flag = false;
+				return null;
+			});
+			if (!flag || !liveRoomInfo || !liveRoomInfo.uid) {
+				flag = false;
+				return flag;
+			}
+			masterInfo = await this.useMasterInfo(liveRoomInfo.uid, masterInfo, liveType).catch(() => {
+				flag = false;
+				return null;
+			});
+			return flag;
+		};
+		const handler = {
+			onError: async () => {
+				liveStatus = false;
+				pushAtTimeTimer?.();
+				this.ctx.bl.closeListener(roomId);
+				await this.sendPrivateMsg(`[${roomId}]直播间连接发生错误！`);
+				this.logger.error(`[${roomId}]直播间连接发生错误！`);
+			},
+			onIncomeDanmu: ({ body }) => {
+				currentLiveDanmakuArr.push(body.content);
+			},
+			onIncomeSuperChat: ({ body }) => {
+				currentLiveDanmakuArr.push(body.content);
+			},
+			onWatchedChange: ({ body }) => {
+				watchedNum = body.text_small;
+			},
+			onGuardBuy: ({ body }) => {
+				const content = `[${masterInfo.username}的直播间]「${body.user.uname}」加入了大航海（${body.gift_name}）`;
+				channelArrLen > 0 && this.broadcastToTargets(liveGuardBuyPushTargetArr, content, require_type.PushType.LiveGuardBuy);
+			},
+			onLiveStart: async () => {
+				if (liveStatus) return;
+				liveStatus = true;
+				if (!await useMasterAndLiveRoomInfo(require_type.LiveType.StartBroadcasting)) {
+					liveStatus = false;
+					await this.sendPrivateMsg("获取直播间信息失败，推送直播开播卡片失败！");
+					return await this.sendPrivateMsgAndStopService();
+				}
+				liveTime = liveRoomInfo.live_time;
+				const follower = masterInfo.liveOpenFollowerNum >= 1e4 ? `${(masterInfo.liveOpenFollowerNum / 1e4).toFixed(1)}万` : masterInfo.liveOpenFollowerNum.toString();
+				const liveStartMsg = this.config.customLiveStart ? this.config.customLiveStart.replace("-name", masterInfo.username).replace("-time", await this.ctx.gi.getTimeDifference(liveTime)).replace("-follower", follower).replace("\\n", "\n").replace("-link", `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`) : null;
+				await this.sendLiveNotifyCard(require_type.LiveType.StartBroadcasting, follower, {
+					liveRoomInfo,
+					masterInfo,
+					cardStyle
+				}, target, liveStartMsg);
+				if (!pushAtTimeTimer) pushAtTimeTimer = this.ctx.setInterval(pushAtTimeFunc, this.config.pushTime * 1e3 * 60 * 60);
+			},
+			onLiveEnd: async () => {
+				liveStatus = false;
+				if (!await useMasterAndLiveRoomInfo(require_type.LiveType.StopBroadcast)) {
+					await this.sendPrivateMsg("获取直播间信息失败，推送直播下播卡片失败！");
+					return await this.sendPrivateMsgAndStopService();
+				}
+				liveRoomInfo.live_time = liveTime;
+				const followerChange = (() => {
+					const liveFollowerChangeNum = masterInfo.liveFollowerChange;
+					if (liveFollowerChangeNum > 0) return liveFollowerChangeNum >= 1e4 ? `+${liveFollowerChangeNum.toFixed(1)}万` : `+${liveFollowerChangeNum}`;
+					return liveFollowerChangeNum <= -1e4 ? `${liveFollowerChangeNum.toFixed(1)}万` : liveFollowerChangeNum.toString();
+				})();
+				const liveEndMsg = this.config.customLiveEnd ? this.config.customLiveEnd.replace("-name", masterInfo.username).replace("-time", await this.ctx.gi.getTimeDifference(liveTime)).replace("-follower_change", followerChange).replace("\\n", "\n") : null;
+				await this.sendLiveNotifyCard(require_type.LiveType.StopBroadcast, followerChange, {
+					liveRoomInfo,
+					masterInfo,
+					cardStyle
+				}, target, liveEndMsg);
+				pushAtTimeTimer();
+				pushAtTimeTimer = null;
+			}
+		};
+		await this.ctx.bl.startLiveRoomListener(roomId, handler);
+		if (!await useMasterAndLiveRoomInfo(require_type.LiveType.FirstLiveBroadcast)) return this.sendPrivateMsg("获取直播间信息失败，启动直播间弹幕检测失败！");
+		if (liveRoomInfo.live_status === 1) {
+			liveTime = liveRoomInfo.live_time;
+			const watched = watchedNum || "暂未获取到";
+			const liveMsg = this.config.customLive ? this.config.customLive.replace("-name", masterInfo.username).replace("-time", await this.ctx.gi.getTimeDifference(liveTime)).replace("-watched", watched).replace("\\n", "\n").replace("-link", `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`) : null;
+			if (this.config.restartPush) await this.sendLiveNotifyCard(require_type.LiveType.LiveBroadcast, watched, {
+				liveRoomInfo,
+				masterInfo,
+				cardStyle
+			}, target, liveMsg);
+			if (!pushAtTimeTimer) pushAtTimeTimer = this.ctx.setInterval(pushAtTimeFunc, this.config.pushTime * 1e3 * 60 * 60);
+			liveStatus = true;
+		}
+	}
+	async liveDetectWithAPI() {
+		const useMasterAndLiveRoomInfo = async (liveType, liveStatus) => {
+			let flag = true;
+			liveStatus.liveRoomInfo = await this.useLiveRoomInfo(liveStatus.roomId).catch(() => {
+				flag = false;
+				return null;
+			});
+			if (!flag || !liveStatus.liveRoomInfo?.uid) {
+				flag = false;
+				return flag;
+			}
+			liveStatus.masterInfo = await this.useMasterInfo(liveStatus.liveRoomInfo.uid, liveStatus.masterInfo, liveType).catch(() => {
+				flag = false;
+				return null;
+			});
+			return flag;
+		};
+		const uids = [];
+		for (const [uid] of this.liveStatusManager.entries()) uids.push(uid);
+		const useLiveInfo = async () => {
+			const { data: data$1 } = await require_utils.withRetry(async () => await this.ctx.ba.getLiveRoomInfoByUids(uids), 3).catch(async () => {
+				return void 0;
+			});
+			if (!data$1) {
+				await this.sendPrivateMsgAndStopService();
+				return;
+			}
+			return data$1;
+		};
+		const data = await useLiveInfo();
+		for (const item of Object.values(data)) {
+			const uid = item.uid.toString();
+			const liveStatus = this.liveStatusManager.get(uid);
+			const sub = this.subManager.find((sub$1) => sub$1.uid === uid);
+			if (item.live_status === 1) {
+				liveStatus.live = true;
+				await useMasterAndLiveRoomInfo(require_type.LiveType.FirstLiveBroadcast, liveStatus);
+				if (!liveStatus.liveStartTimeInit) {
+					liveStatus.liveStartTime = liveStatus.liveRoomInfo.live_time;
+					liveStatus.liveStartTimeInit = true;
+				}
+				const liveMsg = this.config.customLive ? this.config.customLive.replace("-name", liveStatus.masterInfo.username).replace("-time", await this.ctx.gi.getTimeDifference(liveStatus.liveStartTime)).replace("-watched", "API模式无法获取").replace("\\n", "\n").replace("-link", `https://live.bilibili.com/${liveStatus.liveRoomInfo.short_id === 0 ? liveStatus.liveRoomInfo.room_id : liveStatus.liveRoomInfo.short_id}`) : null;
+				await this.sendLiveNotifyCard(require_type.LiveType.LiveBroadcast, "API", {
+					liveRoomInfo: liveStatus.liveRoomInfo,
+					masterInfo: liveStatus.masterInfo,
+					cardStyle: sub.card
+				}, sub.target, liveMsg);
+			}
+		}
+		const handler = async () => {
+			const data$1 = await useLiveInfo();
+			for (const item of Object.values(data$1)) {
+				const uid = item.uid.toString();
+				const liveStatus = this.liveStatusManager.get(uid);
+				const sub = this.subManager.find((sub$1) => sub$1.uid === uid);
+				if (!sub) return;
+				switch (item.live_status) {
+					case 0:
+					case 2: {
+						if (liveStatus.live === true) {
+							if (!await useMasterAndLiveRoomInfo(require_type.LiveType.StopBroadcast, liveStatus)) {
+								await this.sendPrivateMsg("获取直播间信息失败，推送直播下播卡片失败！");
+								return await this.sendPrivateMsgAndStopService();
+							}
+							if (liveStatus.liveStartTimeInit) {
+								liveStatus.liveRoomInfo.live_time = liveStatus.liveStartTime;
+								liveStatus.liveStartTimeInit = false;
+							}
+							const followerChange = (() => {
+								const liveFollowerChangeNum = liveStatus.masterInfo.liveFollowerChange;
+								if (liveFollowerChangeNum > 0) return liveFollowerChangeNum >= 1e4 ? `+${liveFollowerChangeNum.toFixed(1)}万` : `+${liveFollowerChangeNum}`;
+								return liveFollowerChangeNum <= -1e4 ? `${liveFollowerChangeNum.toFixed(1)}万` : liveFollowerChangeNum.toString();
+							})();
+							const liveEndMsg = this.config.customLiveEnd ? this.config.customLiveEnd.replace("-name", liveStatus.masterInfo.username).replace("-time", await this.ctx.gi.getTimeDifference(liveStatus.liveStartTime)).replace("-follower_change", followerChange).replace("\\n", "\n") : null;
+							await this.sendLiveNotifyCard(require_type.LiveType.StopBroadcast, followerChange, {
+								liveRoomInfo: liveStatus.liveRoomInfo,
+								masterInfo: liveStatus.masterInfo,
+								cardStyle: sub.card
+							}, sub.target, liveEndMsg);
+							liveStatus.live = false;
+						}
+						break;
+					}
+					case 1: {
+						if (liveStatus.live === false) {
+							if (!await useMasterAndLiveRoomInfo(require_type.LiveType.StopBroadcast, liveStatus)) {
+								await this.sendPrivateMsg("获取直播间信息失败，推送直播开播卡片失败！");
+								return await this.sendPrivateMsgAndStopService();
+							}
+							liveStatus.liveStartTime = liveStatus.liveRoomInfo.live_time;
+							liveStatus.liveStartTimeInit = true;
+							const follower = liveStatus.masterInfo.liveOpenFollowerNum >= 1e4 ? `${(liveStatus.masterInfo.liveOpenFollowerNum / 1e4).toFixed(1)}万` : liveStatus.masterInfo.liveOpenFollowerNum.toString();
+							const liveStartMsg = this.config.customLiveStart ? this.config.customLiveStart.replace("-name", liveStatus.masterInfo.username).replace("-time", await this.ctx.gi.getTimeDifference(liveStatus.liveStartTime)).replace("-follower", follower).replace("\\n", "\n").replace("-link", `https://live.bilibili.com/${liveStatus.liveRoomInfo.short_id === 0 ? liveStatus.liveRoomInfo.room_id : liveStatus.liveRoomInfo.short_id}`) : null;
+							await this.sendLiveNotifyCard(require_type.LiveType.StartBroadcasting, follower, {
+								liveRoomInfo: liveStatus.liveRoomInfo,
+								masterInfo: liveStatus.masterInfo,
+								cardStyle: sub.card
+							}, sub.target, liveStartMsg);
+							liveStatus.live = true;
+						}
+						if (liveStatus.live === true) {
+							if (liveStatus.push < this.config.pushTime * 60 * 60 / 30) {
+								liveStatus.push++;
+								break;
+							}
+							if (!await useMasterAndLiveRoomInfo(require_type.LiveType.LiveBroadcast, liveStatus)) {
+								await this.sendPrivateMsg("获取直播间信息失败，推送直播卡片失败！");
+								return await this.sendPrivateMsgAndStopService();
+							}
+							if (!liveStatus.liveStartTimeInit) {
+								liveStatus.liveStartTime = liveStatus.liveRoomInfo.live_time;
+								liveStatus.liveStartTimeInit = true;
+							}
+							const liveMsg = this.config.customLive ? this.config.customLive.replace("-name", liveStatus.masterInfo.username).replace("-time", await this.ctx.gi.getTimeDifference(liveStatus.liveStartTime)).replace("-watched", "API模式无法获取").replace("\\n", "\n").replace("-link", `https://live.bilibili.com/${liveStatus.liveRoomInfo.short_id === 0 ? liveStatus.liveRoomInfo.room_id : liveStatus.liveRoomInfo.short_id}`) : null;
+							await this.sendLiveNotifyCard(require_type.LiveType.LiveBroadcast, "API", {
+								liveRoomInfo: liveStatus.liveRoomInfo,
+								masterInfo: liveStatus.masterInfo,
+								cardStyle: sub.card
+							}, sub.target, liveMsg);
+							liveStatus.push = 0;
+						}
+						break;
+					}
+					default: break;
+				}
+			}
+		};
+		return require_utils.withLock(handler);
+	}
+	subShow() {
+		let table = "";
+		for (const sub of this.subManager) table += `UID:${sub.uid}  ${sub.dynamic ? "已订阅动态" : ""}  ${sub.live ? "已订阅直播" : ""}\n`;
+		return table ? table : "没有订阅任何UP";
+	}
+	updateSubNotifier() {
+		if (this.subNotifier) this.subNotifier.dispose();
+		const subInfo = this.subShow();
+		let table = "";
+		if (subInfo === "没有订阅任何UP") table = subInfo;
+		else {
+			const subTableArray = subInfo.split("\n");
+			subTableArray.splice(subTableArray.length - 1, 1);
+			table = /* @__PURE__ */ (0, __satorijs_element_jsx_runtime.jsxs)(__satorijs_element_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, __satorijs_element_jsx_runtime.jsx)("p", { children: "当前订阅对象：" }), /* @__PURE__ */ (0, __satorijs_element_jsx_runtime.jsx)("ul", { children: subTableArray.map((str) => /* @__PURE__ */ (0, __satorijs_element_jsx_runtime.jsx)("li", { children: str })) })] });
+		}
+		this.subNotifier = this.ctx.notifier.create(table);
+	}
+	async checkIfLoginInfoIsLoaded() {
+		return new Promise((resolve) => {
+			const check = () => {
+				if (!this.ctx.ba.getLoginInfoIsLoaded()) this.ctx.setTimeout(check, 500);
+				else resolve("success");
+			};
+			check();
+		});
+	}
+	async subUserInBili(mid) {
+		const checkGroupIsReady = async () => {
+			if (!this.loginDBData?.dynamic_group_id) {
+				const createGroupData = await this.ctx.ba.createGroup("订阅");
+				if (createGroupData.code === 22106) {
+					const allGroupData = await this.ctx.ba.getAllGroup();
+					for (const group of allGroupData.data) if (group.name === "订阅") {
+						this.loginDBData.dynamic_group_id = group.tagid.toString();
+						this.ctx.database.set("loginBili", 1, { dynamic_group_id: this.loginDBData.dynamic_group_id });
+						return {
+							code: 0,
+							msg: "分组已存在"
+						};
+					}
+				} else if (createGroupData.code !== 0) return {
+					code: createGroupData.code,
+					msg: createGroupData.message
+				};
+				this.ctx.database.set("loginBili", 1, { dynamic_group_id: createGroupData.data.tagid.toString() });
+				return {
+					code: createGroupData.code,
+					msg: createGroupData.message
+				};
+			}
+			return {
+				code: 0,
+				msg: "分组已存在"
+			};
+		};
+		const resp = await checkGroupIsReady();
+		if (resp.code !== 0) return resp;
+		const getGroupDetailData = async () => {
+			const relationGroupDetailData = await this.ctx.ba.getRelationGroupDetail(this.loginDBData.dynamic_group_id);
+			if (relationGroupDetailData.code !== 0) {
+				if (relationGroupDetailData.code === 22104) {
+					this.loginDBData.dynamic_group_id = null;
+					const resp$1 = await checkGroupIsReady();
+					if (resp$1.code !== 0) return resp$1;
+					return getGroupDetailData();
+				}
+				return {
+					code: relationGroupDetailData.code,
+					msg: relationGroupDetailData.message,
+					data: void 0
+				};
+			}
+			return {
+				code: 0,
+				msg: "获取分组明细成功",
+				data: relationGroupDetailData.data
+			};
+		};
+		const { code, msg, data } = await getGroupDetailData();
+		if (code !== 0) return {
+			code,
+			msg
+		};
+		for (const user of data) if (user.mid === mid) return {
+			code: 0,
+			msg: "订阅对象已存在于分组中"
+		};
+		const subUserData = await this.ctx.ba.follow(mid);
+		const subUserMatchPattern = {
+			[-101]: () => {
+				return {
+					code: subUserData.code,
+					msg: "账号未登录，请使用指令bili login登录后再进行订阅操作"
+				};
+			},
+			[-102]: () => {
+				return {
+					code: subUserData.code,
+					msg: "账号被封停，无法进行订阅操作"
+				};
+			},
+			[22002]: () => {
+				return {
+					code: subUserData.code,
+					msg: "因对方隐私设置，无法进行订阅操作"
+				};
+			},
+			[22003]: () => {
+				return {
+					code: subUserData.code,
+					msg: "你已将对方拉黑，无法进行订阅操作"
+				};
+			},
+			[22013]: () => {
+				return {
+					code: subUserData.code,
+					msg: "账号已注销，无法进行订阅操作"
+				};
+			},
+			[40061]: () => {
+				return {
+					code: subUserData.code,
+					msg: "账号不存在，请检查uid输入是否正确或用户是否存在"
+				};
+			},
+			[22001]: () => {
+				return {
+					code: 0,
+					msg: "订阅对象为自己，无需添加到分组"
+				};
+			},
+			[22014]: async () => {
+				const copyUserToGroupData = await this.ctx.ba.copyUserToGroup(mid, this.loginDBData.dynamic_group_id);
+				if (copyUserToGroupData.code !== 0) return {
+					code: copyUserToGroupData.code,
+					msg: "添加订阅对象到分组失败，请稍后重试"
+				};
+				return {
+					code: 0,
+					msg: "订阅对象添加成功"
+				};
+			},
+			[0]: async () => {
+				const copyUserToGroupData = await this.ctx.ba.copyUserToGroup(mid, this.loginDBData.dynamic_group_id);
+				if (copyUserToGroupData.code !== 0) return {
+					code: copyUserToGroupData.code,
+					msg: "添加订阅对象到分组失败，请稍后重试"
+				};
+				return {
+					code: 0,
+					msg: "订阅对象添加成功"
+				};
+			}
+		};
+		return await subUserMatchPattern[subUserData.code]();
+	}
+	async loadSubFromConfig(subs) {
+		for (const sub of subs) {
+			this.logger.info(`加载订阅UID:${sub.uid}中...`);
+			const { code: userInfoCode, msg: userInfoMsg, data: userInfoData } = await require_utils.withRetry(async () => {
+				const data = await this.ctx.ba.getUserInfo(sub.uid);
+				return {
+					code: 0,
+					data
+				};
+			}).then((content) => content.data).catch((e) => {
+				this.logger.error(`loadSubFromConfig() getUserInfo() 发生了错误，错误为：${e.message}`);
+				return {
+					code: -1,
+					message: `加载订阅UID:${sub.uid}失败！`
+				};
+			});
+			if (userInfoCode !== 0) return {
+				code: userInfoCode,
+				msg: userInfoMsg
+			};
+			if (this.config.liveDetectType === "WS" && sub.live) {
+				if (!userInfoData.live_room) {
+					sub.live = false;
+					this.logger.warn(`UID:${sub.uid} 用户没有开通直播间，无法订阅直播！`);
+				}
+				if (sub.live) await this.liveDetectWithListener(userInfoData.live_room.roomid, sub.target, sub.card);
+			}
+			const subInfo = await this.subUserInBili(sub.uid);
+			if (subInfo.code !== 0) return subInfo;
+			this.subManager.push({
+				id: +sub.uid,
+				uid: sub.uid,
+				uname: userInfoData.name,
+				roomId: sub.live ? userInfoData.live_room.roomid : "",
+				target: sub.target,
+				platform: "",
+				live: sub.live,
+				dynamic: sub.dynamic,
+				card: sub.card
+			});
+			this.logger.info(`UID:${sub.uid}订阅加载完毕！`);
+			const randomDelay = Math.floor(Math.random() * 3) + 1;
+			this.logger.info(`随机延迟:${randomDelay}秒`);
+			await this.ctx.sleep(randomDelay * 1e3);
+		}
+		return {
+			code: 0,
+			msg: "订阅加载完毕！"
+		};
+	}
+	checkIfDynamicDetectIsNeeded() {
+		if (this.dynamicTimelineManager.size > 0) this.enableDynamicDetect();
+	}
+	checkIfLiveDetectIsNeeded() {
+		if (this.config.liveDetectType === "API") {
+			if (this.liveStatusManager.size > 0) this.enableLiveDetect();
+		}
+	}
+	enableDynamicDetect() {
+		this.dynamicJob = new cron.CronJob("*/2 * * * *", this.config.dynamicDebugMode ? this.debug_dynamicDetect() : this.dynamicDetect());
+		this.logger.info("动态监测已开启");
+		this.dynamicJob.start();
+	}
+	async enableLiveDetect() {
+		this.liveJob = new cron.CronJob("*/30 * * * * *", await this.liveDetectWithAPI());
+		this.logger.info("直播监测已开启");
+		this.liveJob.start();
+	}
+	async checkIfIsLogin() {
+		if ((await this.ctx.database.get("loginBili", 1)).length !== 0) {
+			if (this.ctx.ba.getCookies() !== "[]") return true;
+		}
+		return false;
+	}
+};
+(function(_ComRegister) {
+	const Config$1 = _ComRegister.Config = koishi.Schema.object({
+		sub: koishi.Schema.array(koishi.Schema.object({
+			uid: koishi.Schema.string().description("订阅用户UID"),
+			dynamic: koishi.Schema.boolean().description("是否订阅用户动态"),
+			live: koishi.Schema.boolean().description("是否订阅用户直播"),
+			target: koishi.Schema.array(koishi.Schema.object({
+				channelArr: koishi.Schema.array(koishi.Schema.object({
+					channelId: koishi.Schema.string().description("频道/群组号"),
+					dynamic: koishi.Schema.boolean().description("该频道/群组是否推送动态信息"),
+					live: koishi.Schema.boolean().description("该频道/群组是否推送直播通知"),
+					liveGuardBuy: koishi.Schema.boolean().description("该频道/群组是否推送弹幕消息"),
+					atAll: koishi.Schema.boolean().description("推送开播通知时是否艾特全体成员"),
+					bot: koishi.Schema.string().description("若您有多个相同平台机器人，可在此填写当前群聊执行推送的机器人账号。不填则默认第一个")
+				})).description("频道/群组信息"),
+				platform: koishi.Schema.string().description("推送平台")
+			})).description("订阅用户需要发送的频道/群组信息"),
+			card: koishi.Schema.object({
+				enable: koishi.Schema.boolean(),
+				cardColorStart: koishi.Schema.string(),
+				cardColorEnd: koishi.Schema.string(),
+				cardBasePlateColor: koishi.Schema.string(),
+				cardBasePlateBorder: koishi.Schema.string()
+			}).description("自定义推送卡片颜色，默认使用插件内置的颜色，设置后会覆盖插件内置的颜色")
+		})).role("table").description("手动输入订阅信息，方便自定义订阅内容，这里的订阅内容不会存入数据库。uid: 订阅用户UID，dynamic: 是否需要订阅动态，live: 是否需要订阅直播"),
+		master: koishi.Schema.object({
+			enable: koishi.Schema.boolean(),
+			platform: koishi.Schema.string(),
+			masterAccount: koishi.Schema.string(),
+			masterAccountGuildId: koishi.Schema.string()
+		}),
+		liveDetectType: koishi.Schema.string(),
+		restartPush: koishi.Schema.boolean().required(),
+		pushTime: koishi.Schema.number().required(),
+		pushImgsInDynamic: koishi.Schema.boolean().required(),
+		liveLoopTime: koishi.Schema.number().default(10),
+		customLiveStart: koishi.Schema.string().required(),
+		customLive: koishi.Schema.string(),
+		customLiveEnd: koishi.Schema.string().required(),
+		dynamicUrl: koishi.Schema.boolean().required(),
+		dynamicVideoUrlToBV: koishi.Schema.boolean().required(),
+		filter: koishi.Schema.object({
+			enable: koishi.Schema.boolean(),
+			notify: koishi.Schema.boolean(),
+			regex: koishi.Schema.string(),
+			keywords: koishi.Schema.array(String)
+		}),
+		dynamicDebugMode: koishi.Schema.boolean().required()
+	});
+})(ComRegister || (ComRegister = {}));
+var comRegister_default = ComRegister;
+
+//#endregion
+Object.defineProperty(exports, 'comRegister_default', {
+  enumerable: true,
+  get: function () {
+    return comRegister_default;
+  }
+});