node-karin 1.15.5 → 1.16.1

package/dist/app-DdMQbBEY.mjs

@@ -0,0 +1,4109 @@
+import { t as __exportAll } from "./chunk-NzVPYdc1.mjs";
+import { consolePath, karinPathConfig, karinPathPlugins, logsPath } from "./root.mjs";
+import { $n as setConfig, Ai as isPnpm10, Di as requireFileSync, Fn as updatePkg, In as importModule, Ln as imports, N as getBotCount, Ni as isWorkspace, Rn as isClass, Wn as isLocalRequest, _ as taskSystem, _n as createPluginMismatchReporter, a as getPrivatesFileData, ar as getSecretOrPrivateKey, br as createUnauthorizedResponse, c as config, cr as verifyRefreshToken, dr as createBadRequestResponse, er as updateLevel, fr as createForbiddenResponse, gn as getPluginsInfo, gr as createRefreshTokenExpiredResponse, hn as getPlugins, hr as createPayloadTooLargeResponse, i as getRenderCfg, ir as createJwt, ji as isTs, ki as isDev, mr as createNotFoundResponse, n as redis, nr as getEnv, o as getGroupsFileData, or as refreshAccessToken, pr as createMethodNotAllowedResponse, r as pm2, rr as writeEnv, u as adapter, vr as createServerErrorResponse, wn as restartDirect, yn as satisfies, yr as createSuccessResponse } from "./file-ZGuqNDd-.mjs";
+import { a as mkdirSync } from "./fsSync-Cf5MWILk.mjs";
+import { c as downloadFile, o as createPluginDir } from "./file-dGy9of8-.mjs";
+import { S as cache, d as WS_CLOSE_ONEBOT, f as WS_CLOSE_PUPPETEER, g as WS_CONNECTION_PUPPETEER, h as WS_CONNECTION_ONEBOT, n as errorHandler, r as listeners, t as statusListener, w as formatPath } from "./internal-DupfycKE.mjs";
+import { f as exec$3 } from "./uptime-C121X_rq.mjs";
+import { $ as TASK_LOGS_ROUTER, A as GET_TERMINAL_LIST_ROUTER, B as PLUGIN_ADMIN_ROUTER, C as GET_PLUGIN_CONFIG_ROUTER, D as GET_PLUGIN_MARKET_LIST_ROUTER, F as INSTALL_WEBUI_PLUGIN_ROUTER, G as SAVE_PLUGIN_CONFIG_ROUTER, H as RESTART_ROUTER, I as IS_PLUGIN_CONFIG_EXIST_ROUTER, J as SYSTEM_STATUS_KARIN_ROUTER, K as SET_LOG_LEVEL_ROUTER, L as LOGIN_ROUTER, M as GET_WEBUI_PLUGIN_LIST_ROUTER, N as GET_WEBUI_PLUGIN_VERSIONS_ROUTER, O as GET_TASK_LIST_ROUTER, P as INSTALL_PLUGIN_ROUTER, Q as TASK_LIST_ROUTER, R as MANAGE_DEPENDENCIES_ROUTER, T as GET_PLUGIN_LIST_PLUGIN_ADMIN_ROUTER, U as SAVE_CONFIG_ROUTER, V as REFRESH_ROUTER, W as SAVE_NPMRC_ROUTER, X as SYSTEM_STATUS_WS_ROUTER, Y as SYSTEM_STATUS_ROUTER, Z as TASK_DELETE_ROUTER, _ as GET_NETWORK_STATUS_ROUTER, a as CONSOLE_ROUTER, at as UPDATE_TASK_STATUS_ROUTER, b as GET_NPM_CONFIG_ROUTER, c as GET_BOTS_ROUTER, d as GET_LOADED_COMMAND_PLUGIN_CACHE_LIST_ROUTER, et as TASK_RUN_ROUTER, f as GET_LOCAL_PLUGIN_FRONTEND_LIST_ROUTER, g as GET_LOG_ROUTER, h as GET_LOG_FILE_ROUTER, i as CLOSE_TERMINAL_ROUTER, k as GET_TASK_STATUS_ROUTER, l as GET_CONFIG_ROUTER, m as GET_LOG_FILE_LIST_ROUTER, nt as UNINSTALL_WEBUI_PLUGIN_ROUTER, o as CREATE_TERMINAL_ROUTER, ot as UPDATE_WEBUI_PLUGIN_VERSION_ROUTER, p as GET_LOCAL_PLUGIN_LIST_ROUTER, r as CHECK_PLUGIN_ROUTER, rt as UPDATE_CORE_ROUTER, s as EXIT_ROUTER, t as BASE_ROUTER, tt as UNINSTALL_PLUGIN_ROUTER, u as GET_DEPENDENCIES_LIST_ROUTER, v as GET_NPMRC_LIST_ROUTER, y as GET_NPM_BASE_CONFIG_ROUTER, z as PING_ROUTER } from "./router-zPSN9-tY.mjs";
+import { c as ini, f as getFastRegistry, h as raceRequest, i as initialize, n as createTerminal, o as auth, p as getPackageJson, r as getTerminalList, t as closeTerminal, u as getFastGithub } from "./terminalManager-Lxa8Sm06.mjs";
+import { n as redis$1 } from "./redis-aLJ7wbJH.mjs";
+import "./kv-DZp4UIxg.mjs";
+import path, { join } from "node:path";
+import util from "node:util";
+import path$1 from "path";
+import fs, { existsSync, promises } from "node:fs";
+import { exec, spawn } from "node:child_process";
+import { URL, pathToFileURL } from "node:url";
+import axios, { AxiosError } from "axios";
+import lodash from "lodash";
+import { homedir } from "node:os";
+import { spawn as spawn$1 } from "child_process";
+import schedule from "node-schedule";
+import fs$1 from "fs";
+import moment from "moment";
+import express, { Router } from "express";
+import { createServer } from "node:http";
+
+//#region src/env/key/redis.ts
+/** redis: 插件市场缓存键名 */
+const REDIS_PLUGIN_LIST_CACHE_KEY = "karin:market:plugin:list";
+/** redis: 依赖列表缓存键名 */
+const REDIS_DEPENDENCIES_LIST_CACHE_KEY = "karin:dependencies:list";
+/** redis: 插件市场列表缓存键名 */
+const REDIS_PLUGIN_MARKET_LIST_CACHE_KEY = "karin:market:plugin:list:v2";
+/** redis: 本地插件列表缓存键名 */
+const REDIS_LOCAL_PLUGIN_LIST_CACHE_KEY = "karin:local:plugin:list";
+/** redis: 本地插件列表缓存键名 用于前端显示插件简约列表  */
+const REDIS_LOCAL_PLUGIN_LIST_CACHE_KEY_FRONTEND = "karin:local:plugin:list:frontend";
+/** redis: 依赖列表缓存过期时间 24小时 */
+const REDIS_DEPENDENCIES_LIST_CACHE_EXPIRE = 1440 * 60;
+/** redis: 插件市场列表缓存过期时间 24小时 */
+const REDIS_PLUGIN_MARKET_LIST_CACHE_EXPIRE = 1440 * 60;
+/** redis: 本地插件列表缓存过期时间 24小时 */
+const REDIS_PLUGIN_LIST_CACHE_EXPIRE = 1440 * 60;
+/** redis: 本地插件列表缓存过期时间 24小时 用于前端显示插件简约列表 */
+const REDIS_LOCAL_PLUGIN_LIST_CACHE_EXPIRE_FRONTEND = 1440 * 60;
+
+//#endregion
+//#region src/env/key/event.ts
+/** Bot上线事件 也就是初始化完成了... */
+const ONLINE = "online";
+
+//#endregion
+//#region src/utils/git/exec.ts
+/**
+* 执行命令
+* @param cmd 命令
+* @param options 选项
+* @returns 执行结果
+*/
+const exec$2 = (cmd, options) => {
+	return new Promise((resolve) => {
+		const timeout = (options?.timeout || 30) * 1e3;
+		const timer = setTimeout(() => {
+			resolve({
+				status: false,
+				error: /* @__PURE__ */ new Error("命令执行超时"),
+				stdout: "",
+				stderr: "命令执行超时"
+			});
+		}, timeout);
+		exec(cmd, options, (error, stdout, stderr) => {
+			clearTimeout(timer);
+			stderr = stderr.toString().trim();
+			stdout = stdout.toString().trim();
+			resolve({
+				status: !error,
+				error,
+				stdout,
+				stderr
+			});
+		}).stdin?.write("\n");
+	});
+};
+/**
+* 返回值处理
+* @param data 执行结果
+* @param callback 回调函数
+* @returns 执行结果
+*/
+const handleReturn$1 = (data, callback) => {
+	if (data.error || typeof data.stdout !== "string") throw data.error || /* @__PURE__ */ new Error("stdout 类型错误");
+	if (callback) return callback();
+	return data.stdout;
+};
+
+//#endregion
+//#region src/utils/git/branch.ts
+/**
+* 2025年4月8日22:35:19
+* 此文件较为特殊，需要同时在core内部和cli使用，因此需要保持解耦。
+*/
+/**
+* 获取本地分支列表
+* @param cwd 仓库路径 默认当前目录
+* @returns 本地分支列表 包含默认分支和分支列表
+* @throws 执行发生错误 例如stdout类型错误
+*/
+const getLocalBranches = async (cwd = process.cwd()) => {
+	const data = await exec$2("git --no-pager branch", { cwd });
+	return handleReturn$1(data, () => {
+		/** 默认分支 */
+		let defaultBranch = "";
+		const list = data.stdout.split("\n").map((line) => {
+			line = line.trim();
+			if (line.startsWith("*")) {
+				line = line.replace("*", "").trim();
+				defaultBranch = line;
+			}
+			return line;
+		});
+		return {
+			defaultBranch,
+			list
+		};
+	});
+};
+/**
+* 获取本地默认分支
+* @param cwd 仓库路径 默认当前目录
+* @returns 默认分支
+*/
+const getDefaultBranch = async (cwd = process.cwd()) => {
+	const { defaultBranch } = await getLocalBranches(cwd);
+	return defaultBranch;
+};
+/**
+* 获取git仓库远程分支列表
+* @param cwd 仓库路径
+* @returns 远程分支列表 包含哈希和分支名称
+* @throws 执行发生错误 例如stdout类型错误
+*/
+const getRemoteBranches = async (cwd) => {
+	const data = await exec$2("git ls-remote --heads origin", { cwd });
+	return handleReturn$1(data, () => {
+		return data.stdout.split("\n").map((line) => {
+			const [hash, ref] = line.trim().split(/\s+/).map((v) => v.trim());
+			return {
+				branch: ref.replace("refs/heads/", ""),
+				short: hash.slice(0, 7),
+				hash
+			};
+		});
+	});
+};
+/**
+* 获取本地最新提交哈希
+* @param cwd 仓库路径
+* @param options.branch 分支名称 默认使用当前分支
+* @param options.short 是否返回短哈希 默认返回长哈希
+* @returns 最新提交哈希
+*/
+const getLocalCommitHash = async (cwd, options) => {
+	const branch = options?.branch || "HEAD";
+	return handleReturn$1(await exec$2(`git rev-parse ${options?.short ? "--short" : ""} ${branch}`, { cwd }));
+};
+/**
+* 获取远程最新提交哈希
+* @description 分支名称支持不带origin/前缀 会自动添加
+* @param cwd 仓库路径
+* @param options.branch 分支名称 默认值`origin/HEAD`
+* @param options.short 是否返回短哈希 默认返回长哈希
+* @returns 远程最新提交哈希
+*/
+const getRemoteCommitHash = async (cwd, options) => {
+	let branch = options?.branch || "origin/HEAD";
+	if (!branch.startsWith("origin/")) branch = `origin/${branch}`;
+	return handleReturn$1(await exec$2(`git rev-parse ${options?.short ? "--short" : ""} ${branch}`, { cwd }));
+};
+
+//#endregion
+//#region src/utils/git/pull.ts
+/**
+* 构建pull返回值
+* @param status 是否成功
+* @param currentHash 当前哈希
+* @param remoteHash 远程哈希
+* @param data 更新信息
+* @param prefix data前缀
+* @returns 返回值
+*/
+const pullResult = (status, currentHash, remoteHash, data, prefix = "") => {
+	return {
+		status,
+		data: typeof data === "string" ? data : `${prefix}${data.message || data.stack || "未知错误"}`,
+		hash: {
+			before: currentHash,
+			after: remoteHash
+		}
+	};
+};
+/**
+* 拉取git仓库 俗称`更新git插件`
+* @param cwd 工作目录 默认当前目录
+* @param options 选项
+* @returns 拉取结果
+*/
+const gitPull = async (cwd, options = {}) => {
+	try {
+		/** 先记录当前哈希 */
+		const currentHash = await getLocalCommitHash(cwd);
+		/** 获取远程哈希 */
+		const remoteHash = await getRemoteCommitHash(cwd);
+		if (currentHash === remoteHash) return pullResult(false, currentHash, remoteHash, "当前已经是最新版本");
+		/** 如果是强制拉取 则直接丢弃全部修改 将分支强制与远程分支同步 */
+		if (options.force) {
+			const remote = options.remote || "origin/HEAD";
+			const fetchResult = await exec$2("git fetch origin", {
+				cwd,
+				...options
+			});
+			if (fetchResult.error) return pullResult(false, currentHash, remoteHash, fetchResult.error, "同步远程分支失败: ");
+			const resetResult = await exec$2(`git reset --hard ${remote}`, {
+				cwd,
+				...options
+			});
+			if (resetResult.error) return pullResult(false, currentHash, remoteHash, resetResult.error, "强制同步远程分支失败: ");
+			return pullResult(true, currentHash, await getLocalCommitHash(cwd), "本地分支已强制与远程分支同步");
+		}
+		const { error } = await exec$2(options.customCmd || "git pull", {
+			...options,
+			cwd
+		});
+		if (error) return pullResult(false, currentHash, remoteHash, error, "更新失败: ");
+		return pullResult(true, currentHash, await getLocalCommitHash(cwd), "更新成功");
+	} catch (error) {
+		return pullResult(false, "", "", error.message, "发生错误: ");
+	}
+};
+
+//#endregion
+//#region src/plugin/tools.ts
+/**
+* 创建日志方法
+* @param enable 是否启用
+* @param isBot 是否为bot
+*/
+const createLogger = (enable, isBot) => {
+	if (isBot) return enable === false ? (id, log) => logger.bot("debug", id, log) : (id, log) => logger.bot("mark", id, log);
+	return enable === false ? (log) => logger.debug(log) : (log) => logger.mark(log);
+};
+/**
+* 创建插件文件对象
+* @param type - 文件类型
+*/
+const createFile$1 = (type, name) => {
+	return {
+		absPath: "",
+		basename: "",
+		dirname: "",
+		method: "",
+		type,
+		name
+	};
+};
+/**
+* 创建插件pkg对象
+*/
+const createPkg = () => {
+	return {
+		name: "",
+		apps: [],
+		dir: "",
+		id: -1,
+		pkgData: {},
+		pkgPath: "",
+		type: "app",
+		allApps: []
+	};
+};
+
+//#endregion
+//#region src/plugin/admin/load.ts
+/** 插件ID */
+let seq = 0;
+/**
+* 加载插件包
+* @param pkg 插件包
+* @param allPromises 所有Promise
+*
+* @description 此处所有的加载都是异步的 所以需要传入Promise数组
+*/
+const pkgLoads = async (pkg, allPromises) => {
+	/** 验证版本兼容性 */
+	const reporter = createPluginMismatchReporter();
+	let isCompatible = true;
+	let shouldLoad = true;
+	if (pkg.type !== "app") {
+		/** 版本范围优先级：karin.engines > engines.karin > engines['node-karin'] */
+		const ignoreEngines = pkg.pkgData?.karin?.ignoreEngines === true;
+		const preferred = typeof pkg.pkgData?.karin?.engines === "string" ? String(pkg.pkgData.karin.engines).trim() : "";
+		let fallback = "";
+		if (!preferred) {
+			if (typeof pkg.pkgData?.engines?.karin === "string") fallback = String(pkg.pkgData.engines.karin).trim();
+			else if (typeof pkg.pkgData?.engines?.["node-karin"] === "string") fallback = String(pkg.pkgData.engines["node-karin"]).trim();
+		}
+		const range = preferred || fallback;
+		isCompatible = !range || satisfies(range, process.env.KARIN_VERSION);
+		if (range && !isCompatible) {
+			if (!ignoreEngines) {
+				/** 未忽略：打印日志并禁止加载 */
+				reporter.add(pkg.name, range);
+				await reporter.flush(true, process.env.KARIN_VERSION);
+				shouldLoad = false;
+			}
+		}
+	}
+	/** 如果不应该加载，直接返回 */
+	if (!shouldLoad) return;
+	pkg.id = ++seq;
+	cache.index[pkg.id] = pkg;
+	const files = [];
+	if (pkg.type === "app") files.push("config", "data", "resources");
+	else if (pkg.pkgData.karin?.files && Array.isArray(pkg.pkgData.karin?.files)) files.push(...pkg.pkgData.karin.files);
+	/** 创建插件基本文件夹 - 这个需要立即执行 */
+	await createPluginDir(pkg.name, files);
+	/** 收集入口文件加载的Promise：仅非app类型插件执行入口 */
+	if (pkg.type !== "app" && shouldLoad) {
+		const main = pkg.type === "npm" || !isTs() ? await loadMainFile(pkg, pkg.pkgData?.main) : await loadMainFile(pkg, pkg.pkgData?.karin?.main);
+		if (main && main.KARIN_PLUGIN_INIT) try {
+			await main.KARIN_PLUGIN_INIT();
+			logger.debug(`[load][${pkg.name}] 插件执行KARIN_PLUGIN_INIT函数成功`);
+		} catch (error) {
+			logger.error(new Error(`[load][${pkg.name}] 插件执行KARIN_PLUGIN_INIT函数失败`, { cause: error }));
+		}
+	}
+	/** 收集所有app加载的Promise */
+	shouldLoad && pkg.apps.forEach((app) => {
+		const promise = async () => {
+			pkgCache(await pkgLoadModule(pkg.name, app), pkg, app);
+		};
+		allPromises.push(promise());
+	});
+	/** 静态资源目录处理 */
+	if (pkg.type !== "app" && pkg?.pkgData?.karin?.static) {
+		const list = Array.isArray(pkg.pkgData.karin.static) ? pkg.pkgData.karin.static : [pkg.pkgData.karin.static];
+		cache.static.push(...list.map((file) => path.resolve(pkg.dir, file)));
+	} else {
+		/** 如果没有配置 默认使用 resource、resources 目录 */
+		cache.static.push(path.resolve(pkg.dir, "resource"));
+		cache.static.push(path.resolve(pkg.dir, "resources"));
+	}
+};
+/**
+* 加载入口文件
+* @param pkg 插件包
+* @param dir 入口文件路径
+*/
+const loadMainFile = async (pkg, dir) => {
+	if (!dir) return;
+	const file = path.join(pkg.dir, dir);
+	if (fs.existsSync(file)) return pkgLoadModule(pkg.name, file);
+	return null;
+};
+/**
+* 加载模块 ts、js
+* @param name 插件名称
+* @param file 文件路径
+* @param isRefresh 是否刷新
+*/
+const pkgLoadModule = async (name, file, isRefresh = false) => {
+	const { status, data } = await importModule(file, isRefresh);
+	if (status) return data;
+	logger.debug(new Error(`加载模块失败: ${name} ${file}`, { cause: data }));
+	errorHandler.loaderPlugin(name, file, data);
+	return {};
+};
+/**
+* 判断是否为指定类型
+* @param val 插件方法
+* @param type 插件类型
+*/
+const isType = (val, type) => {
+	return val.file?.type === type;
+};
+/**
+* 缓存插件
+* @param result 插件导入结果
+* @param info 插件信息
+*/
+const pkgCache = (result, pkg, app) => {
+	const cacheHandler = (val, key) => {
+		if (typeof val !== "object") return;
+		if (!val?.pkg || !val.file) return;
+		val.pkg = pkg;
+		val.file = createFile(app, val.file.type, key, val.file.name);
+		if (isType(val, "accept")) {
+			cache.count.accept++;
+			cache.accept.push(val);
+			return;
+		}
+		if (isType(val, "command")) {
+			cache.count.command++;
+			cache.command.push(val);
+			return;
+		}
+		if (isType(val, "button")) {
+			cache.count.button++;
+			cache.button.push(val);
+			return;
+		}
+		if (isType(val, "handler")) {
+			if (!cache.handler[val.key]) {
+				cache.count.handler.key++;
+				cache.handler[val.key] = [];
+			}
+			cache.count.handler.fnc++;
+			cache.handler[val.key].push(val);
+			return;
+		}
+		if (isType(val, "task")) {
+			val.schedule = schedule.scheduleJob(val.cron, async () => {
+				try {
+					if (val.type === "skip" && val.running) {
+						val.log(`[定时任务][${val.name}][${val.cron}]: 上一次任务未完成，跳过本次执行`);
+						return;
+					}
+					val.running = true;
+					val.log(`[定时任务][${val.name}][${val.cron}]: 开始执行`);
+					const result = val.fnc();
+					if (util.types.isPromise(result)) await result;
+					val.log(`[定时任务][${val.name}][${val.cron}]: 执行完成`);
+				} catch (error) {
+					errorHandler.taskStart(val.name, val.name, error);
+				} finally {
+					val.running = false;
+				}
+			});
+			cache.count.task++;
+			cache.task.push(val);
+		}
+	};
+	for (const key of Object.keys(result)) {
+		if (key === "default") continue;
+		if (typeof result[key] === "function") {
+			if (!isClass(result[key])) continue;
+			cacheClassPlugin(result[key], pkg, app, key);
+			continue;
+		}
+		const data = result[key];
+		/** 支持导出数组 */
+		for (const val of Array.isArray(data) ? data : [data]) cacheHandler(val, key);
+	}
+};
+/**
+* 处理导入的模块
+* @param app app文件绝对路径
+* @param type 插件类型
+* @param method 插件方法名称
+*/
+const createFile = (app, type, method, name) => {
+	return {
+		absPath: app,
+		get dirname() {
+			return path.dirname(this.absPath);
+		},
+		get basename() {
+			return path.basename(this.absPath);
+		},
+		type,
+		method,
+		name: name || type
+	};
+};
+/**
+* 缓存类命令插件
+* @param result 插件导入结果
+* @param info 插件信息
+* @param pkg 插件包信息
+* @param app app文件绝对路径
+* @param key 插件方法名称
+*/
+const cacheClassPlugin = (Method, pkg, app, _) => {
+	const command = new Method();
+	if (!command.name) {
+		logger.error(`[load][${app}] plugin.name 不能为空`);
+		return;
+	}
+	if (!command.rule || !Array.isArray(command.rule) || command.rule?.length === 0) {
+		logger.error(`[load][${app}] ${command.name} plugin.rule 不能为空`);
+		return;
+	}
+	command.rule.forEach((v) => {
+		/** 没有对应方法跳过 */
+		if (!(v.fnc in command)) return;
+		/** 没有正则跳过 */
+		if (typeof v.reg !== "string" && !(v.reg instanceof RegExp)) return;
+		cache.command.push({
+			pkg,
+			type: "class",
+			log: createLogger(v.log, true),
+			adapter: v.adapter || [],
+			dsbAdapter: v.dsbAdapter || [],
+			Cls: Method,
+			reg: v.reg instanceof RegExp ? v.reg : new RegExp(v.reg),
+			permission: v.permission || "all",
+			event: v.event || command.event || "message",
+			priority: v.priority || 1e4,
+			file: createFile(app, "command", v.fnc, command.name),
+			authFailMsg: v.authFailMsg || true
+		});
+	});
+};
+/**
+* 根据文件路径查找对应的插件包
+*/
+const findPkgByFile = (file) => {
+	file = formatPath(file);
+	return Object.values(cache.index).find((pkg) => pkg.apps.includes(file) || pkg.allApps.some((dir) => file.startsWith(dir)) || pkg.type === "app" && path.normalize(file).startsWith(path.normalize(pkg.dir))) || null;
+};
+/**
+* 排序插件
+* @description 按照插件的优先度从小到大进行排序插件
+*/
+const pkgSort = () => {
+	cache.accept = lodash.sortBy(cache.accept, ["rank"], ["asc"]);
+	cache.command = lodash.sortBy(cache.command, ["rank"], ["asc"]);
+	cache.task = lodash.sortBy(cache.task, ["rank"], ["asc"]);
+	cache.button = lodash.sortBy(cache.button, ["rank"], ["asc"]);
+	for (const key of Object.keys(cache.handler)) cache.handler[key] = lodash.sortBy(cache.handler[key], ["rank"], ["asc"]);
+};
+/**
+* 热加载一个插件包
+* @version 1.8.0
+* @param type 插件类型
+* @param name 插件名称
+*/
+const pkgHotReload = async (type, name) => {
+	/** 收集所有插件加载的Promise */
+	const allPromises = [];
+	const pkg = await getPluginsInfo([`${type}:${name}`], true, true);
+	if (pkg.length === 0) throw new Error(`[load][${type}:${name}] 插件不存在`);
+	await pkgLoads(pkg[0], allPromises);
+	await Promise.allSettled(allPromises);
+	/** 回收缓存 */
+	allPromises.length = 0;
+	/** 排序 */
+	pkgSort();
+};
+
+//#endregion
+//#region src/server/log/index.ts
+/**
+* 日志中间件
+*/
+const logMiddleware = async (req, _, next) => {
+	logger.debug(`[express] 收到请求: 
+method: ${req.method}\nip: ${req.ip}\npath: ${req.path}\nheaders: ${JSON.stringify(req.headers)}\nbody: ${JSON.stringify(req.body)}\n`);
+	next();
+};
+
+//#endregion
+//#region src/server/auth/middleware.ts
+/**
+* 鉴权中间件
+* @param req 请求
+* @param res 响应
+* @param next 下一个中间件
+*/
+const authMiddleware = async (req, res, next) => {
+	/** 白名单 */
+	if (req.path === "/ping" || req.path === "/login" || req.path === "/refresh" || req.path.startsWith("/console")) {
+		next();
+		return;
+	}
+	if (req.method === "POST") {
+		if (!await auth.postAuth(req, res)) return;
+	} else if (req.method === "GET") {
+		if (!await auth.getAuth(req, res)) return;
+	} else {
+		createMethodNotAllowedResponse(res);
+		return;
+	}
+	next();
+};
+
+//#endregion
+//#region src/server/auth/login.ts
+/** 登录限制配置 */
+const IP_LIMIT_CONFIG = {
+	/** 最大尝试次数 */
+	maxAttempts: 5,
+	/** 时间窗口 */
+	timeWindow: 300 * 1e3,
+	/** 封禁时长 */
+	blockDuration: 1800 * 1e3
+};
+/** IP记录 */
+const ipRecords = /* @__PURE__ */ new Map();
+/**
+* 清理过期的IP记录
+*/
+const cleanupIPRecords = () => {
+	const now = Date.now();
+	for (const [ip, record] of ipRecords.entries()) if (record.blockedUntil && record.blockedUntil < now || now - record.firstAttempt > IP_LIMIT_CONFIG.timeWindow) ipRecords.delete(ip);
+};
+/** 每10分钟清理一次过期记录 */
+setInterval(cleanupIPRecords, 600 * 1e3);
+/**
+* 检查IP是否被封禁
+* @param clientIP 客户端IP
+* @param res 响应
+* @returns 是否被封禁
+*/
+const checkIPBlocked = (clientIP, res) => {
+	const now = Date.now();
+	const ipRecord = ipRecords.get(clientIP) || {
+		attempts: 0,
+		firstAttempt: now
+	};
+	if (ipRecord.blockedUntil && ipRecord.blockedUntil > now) {
+		/** 在封禁期间继续尝试,延长封禁时间 */
+		const additionalAttempts = ipRecord.attempts + 1 - IP_LIMIT_CONFIG.maxAttempts;
+		ipRecord.blockedUntil = now + Math.min(IP_LIMIT_CONFIG.blockDuration * additionalAttempts, 1440 * 60 * 1e3);
+		ipRecord.attempts++;
+		ipRecords.set(clientIP, ipRecord);
+		const remainingTime = Math.ceil((ipRecord.blockedUntil - now) / 1e3 / 60);
+		createForbiddenResponse(res, `登录尝试次数过多,请在${remainingTime}分钟后重试`);
+		logger.warn(`${logger.red("login")}: ${clientIP} 继续尝试登录, 当前尝试次数:${ipRecord.attempts}, 封禁时间延长至${remainingTime}分钟`);
+		return {
+			isBlocked: true,
+			ipRecord
+		};
+	}
+	/** 检查是否需要重置计数器 */
+	if (now - ipRecord.firstAttempt > IP_LIMIT_CONFIG.timeWindow) {
+		ipRecord.attempts = 0;
+		ipRecord.firstAttempt = now;
+	}
+	return {
+		isBlocked: false,
+		ipRecord
+	};
+};
+/**
+* 处理登录失败
+* @param clientIP 客户端IP
+* @param ipRecord IP记录
+* @param res 响应
+* @returns 处理结果
+*/
+const handleLoginFailure = (clientIP, ipRecord, res) => {
+	const now = Date.now();
+	ipRecord.attempts++;
+	/** 检查是否超过最大尝试次数 */
+	if (ipRecord.attempts >= IP_LIMIT_CONFIG.maxAttempts) {
+		ipRecord.blockedUntil = now + IP_LIMIT_CONFIG.blockDuration;
+		ipRecords.set(clientIP, ipRecord);
+		const tips = `登录尝试次数过多,请在${Math.ceil(IP_LIMIT_CONFIG.blockDuration / 1e3 / 60)}分钟后重试`;
+		logger.warn(`${logger.red("login")}: ${clientIP} ${tips}`);
+		return createForbiddenResponse(res, tips);
+	}
+	ipRecords.set(clientIP, ipRecord);
+	logger.warn(`${logger.red("login")}: ${clientIP} 密码错误`);
+	return createBadRequestResponse(res, "密码错误");
+};
+/**
+* 处理登录成功
+* @param clientIP 客户端IP
+* @param res 响应
+* @returns 处理结果
+*/
+const handleLoginSuccess = (clientIP, res) => {
+	/** 登录成功，重置该IP的记录 */
+	ipRecords.delete(clientIP);
+	const { userId, accessToken, refreshToken } = createJwt();
+	return createSuccessResponse(res, {
+		userId,
+		accessToken,
+		refreshToken
+	}, "登录成功");
+};
+/**
+* 验证登录凭证
+* @param authorization 授权
+* @returns 是否有效
+*/
+const validateCredentials = (authorization) => {
+	const token = authorization?.replace("Bearer ", "");
+	return token && token === getSecretOrPrivateKey();
+};
+/**
+* 登录路由处理
+*/
+const loginRouter = async (req, res) => {
+	try {
+		const clientIP = req.ip || req.socket.remoteAddress || "unknown";
+		logger.info(`${logger.green("login")}: ${clientIP} ${JSON.stringify(req.body)}`);
+		/** 检查IP限制 */
+		const { isBlocked, ipRecord } = checkIPBlocked(clientIP, res);
+		if (isBlocked) return;
+		/** 验证登录凭证 */
+		const { authorization } = req.body || {};
+		if (!validateCredentials(authorization)) {
+			handleLoginFailure(clientIP, ipRecord, res);
+			return;
+		}
+		handleLoginSuccess(clientIP, res);
+	} catch (error) {
+		logger.error(error);
+		createServerErrorResponse(res, error instanceof Error ? error.message : "服务器错误");
+	}
+};
+
+//#endregion
+//#region src/server/auth/refresh.ts
+/**
+* 刷新访问令牌
+* @param req 请求
+* @param res 响应
+* @returns 响应
+*/
+const refreshRouter = async (req, res) => {
+	try {
+		const { accessToken, refreshToken } = req.body || {};
+		if (!accessToken || !refreshToken) return createBadRequestResponse(res);
+		const { status, data } = verifyRefreshToken(refreshToken);
+		if (!status) {
+			if (data.includes("过期")) return createRefreshTokenExpiredResponse(res);
+			return createUnauthorizedResponse(res, data);
+		}
+		const newAccessToken = refreshAccessToken(data);
+		logger.mark(`[refresh] 刷新访问令牌成功: ${accessToken} -> ${newAccessToken}`);
+		createSuccessResponse(res, { accessToken: newAccessToken }, "刷新成功");
+	} catch (error) {
+		logger.error(error);
+		createServerErrorResponse(res, error instanceof Error ? error.message : "服务器错误");
+	}
+};
+
+//#endregion
+//#region src/server/config/index.ts
+/**
+* 获取配置
+* @param req 请求
+* @param res 响应
+* @returns 配置
+*/
+const getConfig = async (req, res) => {
+	const { type } = req.body;
+	if (type === "config") return createSuccessResponse(res, config());
+	if (type === "adapter") return createSuccessResponse(res, adapter());
+	if (type === "groups") return createSuccessResponse(res, getGroupsFileData(karinPathConfig));
+	if (type === "privates") return createSuccessResponse(res, getPrivatesFileData(karinPathConfig));
+	if (type === "render") return createSuccessResponse(res, getRenderCfg());
+	if (type === "redis") return createSuccessResponse(res, redis());
+	if (type === "pm2") return createSuccessResponse(res, pm2());
+	if (type === "env") return createSuccessResponse(res, getEnv());
+	return createBadRequestResponse(res, "无效的配置类型");
+};
+/**
+* 保存配置
+* @param req 请求
+* @param res 响应
+* @returns 保存配置
+*/
+const saveConfig = async (req, res) => {
+	const list = [
+		"config",
+		"adapter",
+		"render",
+		"pm2",
+		"redis",
+		"groups",
+		"privates",
+		"env"
+	];
+	const { type, data } = req.body;
+	const save = () => {
+		if (type === "env") {
+			writeEnv(Object.entries(data).map(([key, value]) => ({
+				key,
+				value: value.value,
+				comment: value.comment
+			})), void 0, true);
+			return true;
+		}
+		if (list.includes(type)) return setConfig(type, data);
+		return false;
+	};
+	try {
+		if (!save()) return createBadRequestResponse(res, "配置保存失败");
+		createSuccessResponse(res, "配置保存成功");
+	} catch (error) {
+		logger.error(error);
+		createServerErrorResponse(res, error.message);
+	}
+};
+
+//#endregion
+//#region src/server/system/ping.ts
+/**
+* ping路由
+*/
+const pingRouter = (_req, res) => {
+	createSuccessResponse(res, { ping: "pong" }, "成功");
+};
+
+//#endregion
+//#region src/server/plugins/config.ts
+/**
+* 检查文件是否存在
+* @param filepath 文件路径
+* @returns 存在返回true，否则返回false
+*/
+const fileExists = (filepath) => {
+	try {
+		return fs.existsSync(filepath);
+	} catch (error) {
+		return false;
+	}
+};
+/**
+* 从package.json中获取web配置路径
+* @param pkg package.json内容
+* @param baseDir 插件根目录
+* @returns web配置路径或null
+*/
+const getWebConfigPathFromPkg = (pkg, baseDir) => {
+	if (!pkg.karin) return null;
+	/** 如果该插件处于node_modules中 视其为正式插件的环境 仅加载web */
+	if (baseDir.includes("node_modules")) {
+		if (pkg.karin.web) {
+			const configPath = path.join(baseDir, pkg.karin.web);
+			return fileExists(configPath) ? configPath : null;
+		}
+		return null;
+	}
+	let configPath = null;
+	if (isTs()) {
+		if (pkg.karin["ts-web"]) {
+			configPath = path.join(baseDir, pkg.karin["ts-web"]);
+			if (fileExists(configPath)) return configPath;
+		}
+	}
+	if (pkg.karin.web) {
+		configPath = path.join(baseDir, pkg.karin.web);
+		if (fileExists(configPath)) return configPath;
+	}
+	return null;
+};
+/**
+* 获取NPM插件配置路径
+* @param name 插件名称
+* @returns 配置路径或null
+*/
+const getNpmPluginConfigPath = (name) => {
+	const dir = path.join(process.cwd(), "node_modules", name);
+	if (fileExists(dir)) try {
+		const pkgPath = path.join(dir, "package.json");
+		if (fileExists(pkgPath)) {
+			const configPath = getWebConfigPathFromPkg(requireFileSync(pkgPath), dir);
+			if (configPath) return configPath;
+		}
+	} catch (error) {
+		return null;
+	}
+	/** 开发环境检查根目录 */
+	if (isDev()) try {
+		const rootPkgPath = path.join(process.cwd(), "package.json");
+		if (fileExists(rootPkgPath)) {
+			const pkg = requireFileSync(rootPkgPath);
+			if (pkg?.name === name) return getWebConfigPathFromPkg(pkg, process.cwd());
+		}
+	} catch (error) {
+		return null;
+	}
+	return null;
+};
+/**
+* 获取本地插件配置路径
+* @param name 插件名称
+* @returns 配置路径或null
+*/
+const getLocalPluginConfigPath = (name) => {
+	const pluginDir = path.join(process.cwd(), "plugins", name);
+	if (fileExists(pluginDir)) try {
+		const pkgPath = path.join(pluginDir, "package.json");
+		if (fileExists(pkgPath)) {
+			const configPath = getWebConfigPathFromPkg(requireFileSync(pkgPath), pluginDir);
+			if (configPath) return configPath;
+		}
+	} catch (error) {
+		return null;
+	}
+	try {
+		const pkgPath = path.join(process.cwd(), "package.json");
+		if (fileExists(pkgPath)) return getWebConfigPathFromPkg(requireFileSync(pkgPath), process.cwd());
+	} catch (error) {
+		return null;
+	}
+	return null;
+};
+/**
+* 获取插件配置路径
+* @param type 插件类型
+* @param name 插件名称
+* @returns 配置路径
+*/
+const getConfigPath = (type, name) => {
+	try {
+		switch (type) {
+			case "npm": return getNpmPluginConfigPath(name);
+			case "git": return getLocalPluginConfigPath(name);
+			default: return null;
+		}
+	} catch (error) {
+		return null;
+	}
+};
+/**
+* 加载插件配置
+* @param configPath 配置路径
+*/
+const loadConfig = async (configPath) => {
+	try {
+		return (await import(`${pathToFileURL(configPath).toString()}${isDev() ? "?t=" + Date.now() : ""}`)).default;
+	} catch (error) {
+		throw new Error(`加载插件配置失败: ${error instanceof Error ? error.message : String(error)}`);
+	}
+};
+/**
+* 传入type id 返回web.config配置
+* @param type 插件类型
+* @param id 插件id
+* @param fnc 配置文件不符合要求时回调
+* @returns web.config配置
+*/
+const getWebConfig$1 = async (type, id, _) => {
+	/** 只支持git npm */
+	if (!["git", "npm"].includes(type)) return null;
+	const webConfig = getConfigPath(type, id);
+	if (!webConfig) return null;
+	if (path.basename(webConfig, path.extname(webConfig)) !== "web.config") return null;
+	const result = await loadConfig(webConfig);
+	/** 检查一下version description是否存在 不存在则从插件对应的package.json中获取 */
+	if (!result.info.version || !result.info.description) {
+		let dir = "";
+		if (type === "npm") dir = path.join(process.cwd(), "node_modules", id);
+		else {
+			dir = path.join(process.cwd(), "plugins", id);
+			if (!fs.existsSync(dir)) dir = process.cwd();
+		}
+		const pkg = requireFileSync(path.join(dir, "package.json"));
+		if (!pkg || pkg.name !== id) {
+			if (!result.info.version) result.info.version = "";
+			if (!result.info.description) result.info.description = "";
+		} else {
+			if (!result.info.version && pkg.version !== void 0) result.info.version = pkg.version;
+			else result.info.version = "";
+			if (!result.info.description) result.info.description = "";
+		}
+	}
+	return result;
+};
+/**
+* 标准化插件作者字段
+* @param author 插件作者
+* @returns 标准化后的作者
+*/
+const normalizeAuthor = (author) => {
+	const list = [];
+	if (Array.isArray(author)) list.push(...author);
+	else if (author) list.push(author);
+	return list;
+};
+/**
+* 解析自定义配置页面
+* @param config 插件web配置
+*/
+const resolveConfigPage = async (config) => {
+	if (!("page" in config) || !config.page) return void 0;
+	const page = await (typeof config.page === "function" ? config.page() : config.page);
+	if (!page || typeof page.url !== "string" || !page.url.trim()) throw new Error("插件自定义配置页面缺少有效的 url");
+	return {
+		...page,
+		url: normalizeConfigPageUrl(page.url)
+	};
+};
+/**
+* 标准化自定义配置页面地址。
+* @param rawUrl 页面地址
+* @returns 标准化后的页面地址
+*/
+const normalizeConfigPageUrl = (rawUrl) => {
+	const url = rawUrl.trim();
+	if (url.startsWith("/") && !url.startsWith("//")) return url;
+	try {
+		const parsed = new URL(url);
+		if (parsed.protocol === "http:" || parsed.protocol === "https:") return parsed.toString();
+	} catch {}
+	throw new Error("插件自定义配置页面 url 仅支持以 / 开头的同源路径或 http(s) 外部地址");
+};
+/**
+* 获取插件配置 不存在则返回null
+* @param req 请求
+* @param res 响应
+*/
+const pluginGetConfig = async (req, res) => {
+	const options = req.body;
+	if (!options.name) {
+		createServerErrorResponse(res, "参数错误");
+		return;
+	}
+	const type = await getPluginType(options.name);
+	if (!type) return createServerErrorResponse(res, "参数错误");
+	const config = await getWebConfig$1(type, options.name, () => {
+		logger.error(`[plugin] 插件${options.name}的web配置文件名称不正确: 需要以 web.config 命名`);
+		createSuccessResponse(res, null);
+	});
+	if (!config) return createServerErrorResponse(res, "参数错误");
+	let page;
+	try {
+		page = await resolveConfigPage(config);
+	} catch (error) {
+		return createServerErrorResponse(res, error.message);
+	}
+	const list = [];
+	if (typeof config.components === "function") {
+		let result = config.components();
+		result = util.types.isPromise(result) ? await result : result;
+		result.forEach((item) => {
+			if (typeof item?.toJSON === "function") list.push(item.toJSON());
+			else if (typeof item === "object" && item !== null) list.push(item);
+		});
+	} else if (!page) return createServerErrorResponse(res, "该插件未提供默认组件配置函数或自定义配置页面");
+	createSuccessResponse(res, {
+		options: list,
+		page,
+		info: {
+			...config.info,
+			author: normalizeAuthor(config.info.author)
+		}
+	});
+};
+/**
+
+* 保存插件配置
+*/
+const pluginSaveConfig = async (req, res) => {
+	const { name, config } = req.body;
+	const type = await getPluginType(name);
+	if (!type) return createServerErrorResponse(res, "参数错误");
+	const configPath = getConfigPath(type, name);
+	if (!configPath) return createServerErrorResponse(res, "参数错误");
+	const webConfig = await loadConfig(configPath);
+	if ("page" in webConfig && webConfig.page) return createServerErrorResponse(res, "自定义配置页面不支持 Karin 通用保存接口");
+	const { save } = webConfig;
+	if (typeof save !== "function") return createServerErrorResponse(res, "该插件未提供默认组件保存函数");
+	const result = save(config);
+	createSuccessResponse(res, (util.types.isPromise(result) ? await result : result) || {
+		success: true,
+		message: "没有返回值哦 φ(>ω<*) "
+	});
+};
+/**
+* 判断插件是否存在配置
+*/
+const pluginIsConfigExist = async (req, res) => {
+	const name = req.body.name;
+	const type = await getPluginType(name);
+	if (!name || !type) return createServerErrorResponse(res, "参数错误");
+	createSuccessResponse(res, typeof getConfigPath(type, name) === "string");
+};
+/**
+* 获取插件的类型
+* @param name 插件名称
+*/
+const getPluginType = async (name) => {
+	const list = await getPlugins("all", false);
+	const npmName = `npm:${name}`;
+	const gitName = `git:${name}`;
+	const rootName = `root:${name}`;
+	for (const item of list) {
+		if (item === npmName) return "npm";
+		if (item === gitName) return "git";
+		if (item === rootName) return "git";
+	}
+	return null;
+};
+
+//#endregion
+//#region src/server/plugins/local.ts
+/**
+* 获取本地已安装插件列表
+*/
+const pluginGetLocalList = async (req, res) => {
+	const { isForce } = req.body;
+	const [npm, git] = await Promise.all([getPlugins("npm", true, isForce ?? false), getPlugins("git", true, isForce ?? false)]);
+	const list = [...npm, ...git];
+	const result = [];
+	const promise = [];
+	list.forEach((val) => promise.push(isWebConfigPlugin(val, result)));
+	await Promise.all(promise);
+	createSuccessResponse(res, result);
+};
+/**
+* 判断插件是否存在`web.config`
+*/
+const isWebConfigPlugin = async (val, result) => {
+	const pkg = val.pkgData;
+	if (val.type === "npm") {
+		if (!pkg.karin?.web) return;
+		return getWebConfigPlugins(pkg, val, result);
+	}
+	if (isTs()) {
+		if (!pkg.karin?.["ts-web"]) return;
+		return getWebConfigPlugins(pkg, val, result);
+	}
+};
+/**
+* 获取拥有web.config的插件配置
+*/
+const getWebConfigPlugins = async (pkg, val, result) => {
+	let config = null;
+	config = await getWebConfig$1(val.type, val.name);
+	/** 开发环境下兼容获取根目录的 */
+	if (!config && isDev() && val.type === "npm") config = await getWebConfig$1("git", val.name);
+	if (!config || !config.info) return;
+	result.push({
+		...config.info,
+		id: val.name,
+		version: config.info.version ?? pkg.version,
+		description: config.info.description ?? pkg.description,
+		hasConfig: true,
+		type: val.type,
+		author: normalizeAuthor(config.info.author)
+	});
+};
+
+//#endregion
+//#region src/server/console/index.ts
+/** 允许的文件类型及其对应的 Content-Type */
+const ALLOWED_TYPES = {
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".mp3": "audio/mpeg",
+	".mp4": "video/mp4",
+	".wav": "audio/wav",
+	".webp": "image/webp",
+	".json": "application/json",
+	".txt": "text/plain",
+	".html": "text/html",
+	".css": "text/css"
+};
+/** 最大文件大小 (1024MB) */
+const MAX_FILE_SIZE = 1024 * 1024 * 1024;
+/**
+* console适配器路由
+*/
+const consoleRouter = async (req, res) => {
+	try {
+		const cfg = adapter();
+		let url = decodeURIComponent(req.path).replace(/\/+/g, "/").replace(/^\/+|\/+$/g, "");
+		url = url.split("/").pop() || "";
+		if (!url) return createBadRequestResponse(res, "文件名不能为空");
+		/** 防止路径穿越 */
+		if (url.includes("..") || url.includes("~") || !url.match(/^[a-zA-Z0-9-_.]+$/)) return createForbiddenResponse(res, "非法请求");
+		const ext = path.extname(url).toLowerCase();
+		if (!ALLOWED_TYPES[ext]) return createBadRequestResponse(res, "不支持的文件类型");
+		const isLocal = await isLocalRequest(req);
+		if (cfg.console.isLocal) {
+			if (!isLocal) return createForbiddenResponse(res, "非法请求");
+		} else {
+			if (!cfg.console.token) return createServerErrorResponse(res, "缺少 token 配置");
+			const token = req.query.token;
+			if (!token || token !== cfg.console.token) return createForbiddenResponse(res, "无效的 token");
+		}
+		const file = path.join(consolePath, url);
+		try {
+			/** 组合路径之后 判断一下文件是否处于 consolePath 目录下 */
+			if (!file.startsWith(consolePath)) return createForbiddenResponse(res, "非法请求");
+			if ((await promises.stat(file)).size > MAX_FILE_SIZE) return createPayloadTooLargeResponse(res, "文件过大");
+		} catch {
+			return createNotFoundResponse(res, "文件不存在");
+		}
+		const data = await promises.readFile(file);
+		res.setHeader("Content-Type", ALLOWED_TYPES[ext]);
+		res.setHeader("Content-Length", data.length);
+		res.setHeader("X-Content-Type-Options", "nosniff");
+		res.send(data);
+	} catch (error) {
+		console.error("Console router error:", error);
+		return createServerErrorResponse(res, "服务器错误");
+	}
+};
+
+//#endregion
+//#region src/server/system/botList.ts
+/**
+* 获取所有bot列表
+*/
+const getBotsRouter = async (_, res) => {
+	createSuccessResponse(res, getBotCount());
+};
+
+//#endregion
+//#region src/server/system/update.ts
+/**
+* 更新karin
+*/
+const updateCoreRouter = async (_req, res) => {
+	console.log("收到更新请求");
+	const result = await updatePkg("node-karin");
+	if (result.status === "ok") createSuccessResponse(res, result, "更新成功");
+	else createServerErrorResponse(res, "更新失败，请检查日志");
+};
+
+//#endregion
+//#region src/server/system/network.ts
+let network = null;
+/**
+* 获取网络状态
+*/
+const networkStatusRouter = async (_req, res) => {
+	try {
+		if (typeof network !== "function") {
+			const { calculateNetworkSpeed } = await import("@karinjs/plugin-webui-network-monitor");
+			network = calculateNetworkSpeed;
+		}
+		createSuccessResponse(res, await network());
+	} catch (error) {
+		logger.debug(error);
+		createServerErrorResponse(res, "@karinjs/plugin-webui-network-monitor 插件未安装！");
+	}
+};
+
+//#endregion
+//#region src/server/system/manage.ts
+/**
+* 重启karin
+*/
+const restartRouter = async (req, res) => {
+	try {
+		const { isPm2 = false, reloadDeps = false } = req.body;
+		restartDirect({
+			isPm2,
+			reloadDeps
+		});
+		createSuccessResponse(res, null, "重启指令发送成功");
+	} catch (error) {
+		createServerErrorResponse(res, error.message);
+	}
+};
+/**
+* 退出karin
+*/
+const exitRouter = async (_req, res) => {
+	logger.mark("收到退出请求，正在退出...");
+	createSuccessResponse(res, null, "退出指令发送成功");
+	const { processExit } = await import("./index.mjs").then((n) => n.t);
+	await processExit(0, true);
+};
+
+//#endregion
+//#region src/server/system/info.ts
+const wsOneBotSet = /* @__PURE__ */ new Set();
+const wsPuppeteerSet = /* @__PURE__ */ new Set();
+listeners.on(WS_CONNECTION_ONEBOT, (socket) => {
+	wsOneBotSet.add(socket);
+});
+listeners.on(WS_CONNECTION_PUPPETEER, (socket) => {
+	wsPuppeteerSet.add(socket);
+});
+listeners.on(WS_CLOSE_ONEBOT, (socket) => {
+	wsOneBotSet.delete(socket);
+});
+listeners.on(WS_CLOSE_PUPPETEER, (socket) => {
+	wsPuppeteerSet.delete(socket);
+});
+/**
+* 系统信息路由
+*/
+const statusRouter = (_req, res) => {
+	createSuccessResponse(res, {
+		name: "karin",
+		pid: process.pid,
+		pm2_id: process.env.pm_id || "",
+		uptime: process.uptime(),
+		version: process.env.KARIN_VERSION,
+		karin_dev: isDev(),
+		karin_lang: process.env.RUNTIME === "tsx" ? "ts" : "js",
+		karin_runtime: process.env.RUNTIME,
+		platform: process.platform,
+		arch: process.arch
+	}, "成功");
+};
+const infoRouter = async (_req, res) => {
+	createSuccessResponse(res, {
+		onebot: Array.from(wsOneBotSet).map((ws) => {
+			return {
+				readyState: ws.readyState,
+				url: ws.url,
+				protocol: ws.protocol
+			};
+		}),
+		puppeteer: Array.from(wsPuppeteerSet).map((ws) => {
+			return {
+				readyState: ws.readyState,
+				url: ws.url,
+				protocol: ws.protocol
+			};
+		})
+	});
+};
+/**
+* 系统状态实时路由
+*/
+const systemStatusRealTimeHandler = async (req, res) => {
+	res.setHeader("Content-Type", "text/event-stream");
+	res.setHeader("Connection", "keep-alive");
+	const sendStatus = (status) => {
+		try {
+			res.write(`data: ${JSON.stringify(status)}\n\n`);
+		} catch (e) {
+			logger.error(`An error occurred when writing sendStatus data to client: ${e}`);
+		}
+	};
+	statusListener.on("statusUpdate", sendStatus);
+	req.on("close", () => {
+		statusListener.off("statusUpdate", sendStatus);
+		res.end("data: end\n\n");
+	});
+};
+
+//#endregion
+//#region src/server/log/getLog.ts
+/**
+* 检查是否为标准的YYYY-MM-DD格式
+* @param date - 日期字符串
+* @returns 是否为标准的YYYY-MM-DD格式
+*/
+const isStandardDate = (date) => {
+	return typeof date === "string" && /^\d{4}-\d{2}-\d{2}$/.test(date);
+};
+/**
+* 临时修改当前日志等级 重启后恢复
+*/
+const logLevelRouter = async (req, res) => {
+	const level = req.body?.level;
+	if (!level || ![
+		"trace",
+		"debug",
+		"info",
+		"warn",
+		"error",
+		"fatal"
+	].includes(level)) return createBadRequestResponse(res, "参数错误");
+	updateLevel(level);
+	createSuccessResponse(res, null, "修改成功");
+};
+/**
+* 当前活跃的连接数
+*/
+let activeConnections$1 = 0;
+/**
+* 获取当前日志
+* 支持查询指定日期的日志，如果没有指定则获取当天的
+*/
+const getLogRouter = async (req, res) => {
+	const maxConnections = Number(process.env.LOG_API_MAX_CONNECTIONS) || 5;
+	const MAX_CHUNK_SIZE = Number(process.env.LOG_API_MAX_CHUNK_SIZE) || 1024 * 1024;
+	/** 检查连接数是否达到上限 */
+	if (activeConnections$1 >= maxConnections) return createBadRequestResponse(res, "当前连接数已达到上限，请稍后重试");
+	activeConnections$1++;
+	/** 获取日期 */
+	const date = moment();
+	/** 检查日期是否有效 */
+	if (!date.isValid()) {
+		activeConnections$1--;
+		return createBadRequestResponse(res, "日期格式错误");
+	}
+	/** 日志文件路径 */
+	const file = path.join(logsPath, `logger.${date.format("YYYY-MM-DD")}.log`);
+	/** 响应头 */
+	res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+	/** 设置不缓存 */
+	res.setHeader("Cache-Control", "no-cache");
+	/** 设置长连接 */
+	res.setHeader("Connection", "keep-alive");
+	/** 禁用 Nginx 缓冲 */
+	res.setHeader("X-Accel-Buffering", "no");
+	let position = 0;
+	let isStreaming = false;
+	const isEventSource = req.headers.accept === "text/event-stream";
+	const heartbeat = setInterval(() => {
+		if (isEventSource) res.write(":heartbeat\n\n");
+	}, 3e4);
+	const tailFile = () => {
+		if (isStreaming) return;
+		fs.stat(file, (err, stats) => {
+			if (err) {
+				logger.error("读取日志文件状态错误:", err);
+				return;
+			}
+			if (position > stats.size)
+ /** 文件被截断，重置位置 */
+			position = 0;
+			if (position < stats.size) {
+				/** 有新内容，读取并发送 */
+				isStreaming = true;
+				const endPosition = Math.min(position + MAX_CHUNK_SIZE, stats.size);
+				const stream = fs.createReadStream(file, {
+					start: position,
+					end: endPosition - 1,
+					encoding: "utf-8",
+					highWaterMark: 64 * 1024
+				});
+				/** 监听数据流 */
+				stream.on("data", (data) => {
+					const lines = data.toString().split("\n");
+					for (const line of lines) if (line) if (isEventSource) res.write(`data: ${line}\n\n`);
+					else res.write(`${line}\n`);
+				});
+				/** 文件读取完毕 */
+				stream.on("end", () => {
+					position = endPosition;
+					isStreaming = false;
+				});
+				/** 监听错误 */
+				stream.on("error", (error) => {
+					logger.error("读取日志文件错误:", error.message);
+					isStreaming = false;
+				});
+			}
+		});
+	};
+	/** 首次读取 */
+	tailFile();
+	/** 定期检查文件变化 */
+	const interval = setInterval(tailFile, 1e3);
+	req.on("close", () => {
+		clearInterval(interval);
+		clearInterval(heartbeat);
+		activeConnections$1--;
+	});
+	req.on("error", () => {
+		clearInterval(interval);
+		clearInterval(heartbeat);
+		activeConnections$1--;
+	});
+};
+/**
+* 获取日志文件列表
+*/
+const getLogFileListRouter = async (_, res) => {
+	createSuccessResponse(res, fs.readdirSync(logsPath).filter((file) => file.startsWith("logger.") && file.endsWith(".log")).map((file) => file.replace("logger.", "").replace(".log", "")), "成功");
+};
+/**
+* 获取指定日志文件
+* @description 此接口一次性返回所有日志文件内容
+*/
+const getLogFileRouter = async (req, res) => {
+	const file = req.query.file;
+	if (!isStandardDate(file)) return createBadRequestResponse(res, "日期格式错误");
+	const filePath = path.join(logsPath, `logger.${file}.log`);
+	if (!fs.existsSync(filePath)) return createBadRequestResponse(res, "日志文件不存在");
+	const stats = fs.statSync(filePath);
+	const FILE_SIZE_LIMIT = Number(process.env.LOG_FILE_SIZE_LIMIT) || 10 * 1024 * 1024;
+	if (stats.size > FILE_SIZE_LIMIT) return createBadRequestResponse(res, "日志文件过大，请使用流式接口获取或下载文件");
+	createSuccessResponse(res, fs.readFileSync(filePath, "utf-8"), "成功");
+};
+
+//#endregion
+//#region src/server/plugins/cache.ts
+const CACHE_KEY = "karin:web:plugin:list";
+/**
+* 删除插件列表缓存
+*/
+const deletePluginListCache = async () => {
+	try {
+		const { redis } = await import("./redis-aLJ7wbJH.mjs").then((n) => n.r);
+		await redis.del(CACHE_KEY);
+	} catch (error) {
+		logger.error("删除插件列表缓存失败:", error);
+	}
+};
+
+//#endregion
+//#region src/server/plugins/install.ts
+/** 全局任务队列 */
+const taskQueue = /* @__PURE__ */ new Map();
+/**
+* 执行命令并实时获取输出
+* @param command 命令
+* @param args 参数
+* @param task 任务
+*/
+const spawnCommand = (command, args, task) => {
+	if (isWorkspace()) args.push("-w");
+	return new Promise((resolve, reject) => {
+		const child = spawn$1(command, args, {
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			shell: true,
+			cwd: process.cwd()
+		});
+		child.stdout.on("data", (data) => {
+			data.toString().split("\n").filter(Boolean).forEach((line) => {
+				task.logs.push(line);
+			});
+		});
+		child.stderr.on("data", (data) => {
+			data.toString().split("\n").filter(Boolean).forEach((line) => {
+				task.logs.push(`[错误] ${line}`);
+			});
+		});
+		child.on("close", (code) => {
+			if (code === 0) resolve();
+			else reject(/* @__PURE__ */ new Error(`命令执行失败，退出码: ${code}`));
+		});
+		child.on("error", (error) => reject(error));
+	});
+};
+/**
+* 安装 NPM 插件
+* @param task 任务
+*/
+const installNpmPlugin = async (task) => {
+	task.logs.push(`开始安装 NPM 插件: ${task.name}`);
+	task.logs.push("正在解析依赖...");
+	await spawnCommand("pnpm", [
+		"add",
+		task.name,
+		"--save"
+	], task);
+};
+/**
+* 安装 Git 插件
+* @param task 任务
+* @param url 下载地址
+*/
+const installGitPlugin = async (task, url) => {
+	if (!url) throw new Error("Git 插件需要提供仓库地址");
+	const pluginDir = path.join(process.cwd(), "plugins", task.name);
+	task.logs.push(`开始克隆仓库: ${url}`);
+	task.logs.push(`目标目录: ${pluginDir}`);
+	await fs.promises.mkdir(pluginDir, { recursive: true });
+	/** git clone --depth=1 https://github.com/ikenxuan/karin-plugin-kkk.git ./plugins/karin-plugin-kkk/ */
+	await spawnCommand("git", [
+		"clone",
+		"--depth=1",
+		url,
+		`./plugins/${task.name}`
+	], task);
+	/** 检查是否有 package.json */
+	const pkgPath = path.join(pluginDir, "package.json");
+	if (fs.existsSync(pkgPath)) {
+		task.logs.push("检测到 package.json，开始安装依赖...");
+		await spawnCommand("pnpm", ["install"], task);
+	}
+};
+/**
+* 安装 App 插件
+* @param task 任务
+* @param url 下载地址
+*/
+const installAppPlugin = async (task, url) => {
+	if (!url) throw new Error("App 插件需要提供下载地址");
+	/** 非js、ts不允许下载 */
+	if (!url.endsWith(".js") && !url.endsWith(".ts")) throw new Error("非js、ts不允许下载");
+	const pluginDir = path.join(process.cwd(), "plugins", "karin-plugin-example");
+	task.logs.push(`开始下载插件: ${url}`);
+	task.logs.push(`目标目录: ${pluginDir}`);
+	await fs.promises.mkdir(pluginDir, { recursive: true });
+	/** 使用 curl 下载文件，以获取下载进度 */
+	await spawnCommand("curl", [
+		"-L",
+		"-o",
+		pluginDir,
+		url
+	], task);
+};
+/**
+* 执行插件安装任务
+* @param task 任务
+* @param url 下载地址
+*/
+const installPluginTask = async (task, url) => {
+	try {
+		task.status = "running";
+		task.logs.push(`开始安装插件: ${task.name}`);
+		task.logs.push(`插件类型: ${task.type}`);
+		task.logs.push("-------------------");
+		switch (task.type) {
+			case "npm":
+				await installNpmPlugin(task);
+				break;
+			case "git":
+				await installGitPlugin(task, url);
+				break;
+			case "app":
+				await installAppPlugin(task, url);
+				break;
+			default: throw new Error("不支持的插件类型");
+		}
+		task.logs.push("-------------------");
+		task.logs.push("🎉 安装完成!");
+		task.status = "completed";
+		/** 清除插件列表缓存 */
+		await deletePluginListCache();
+	} catch (error) {
+		task.status = "failed";
+		task.error = error.message;
+		task.logs.push("-------------------");
+		task.logs.push(`❌ 安装失败: ${error.message}`);
+		throw error;
+	}
+};
+/**
+* 安装插件
+*/
+const pluginInstall = async (req, res) => {
+	try {
+		const { name, type, url } = req.body;
+		const taskId = `${type}-${name}-${Date.now()}`;
+		if (Array.from(taskQueue.values()).find((task) => task.name === name && task.status === "running")) return createServerErrorResponse(res, "该插件正在安装中");
+		/** 创建新任务 */
+		const task = {
+			id: taskId,
+			name,
+			type,
+			status: "pending",
+			logs: [],
+			minimized: false
+		};
+		taskQueue.set(taskId, task);
+		/** 异步执行安装 */
+		installPluginTask(task, url).catch((error) => {
+			task.status = "failed";
+			task.error = error.message;
+			task.logs.push(`安装失败: ${error.message}`);
+		});
+		createSuccessResponse(res, { taskId });
+	} catch (error) {
+		createServerErrorResponse(res, error.message);
+		logger.error(error);
+	}
+};
+/**
+* 卸载 NPM 插件
+*/
+const uninstallNpmPlugin = async (task) => {
+	task.logs.push(`开始卸载 NPM 插件: ${task.name}`);
+	await spawnCommand("pnpm", ["rm", task.name], task);
+};
+/**
+* 卸载 Git 插件
+* @param task 任务
+*/
+const uninstallGitPlugin = async (task) => {
+	const pluginDir = path.join(process.cwd(), "plugins", task.name);
+	task.logs.push(`开始删除插件目录: ${pluginDir}`);
+	/** 删除插件目录 */
+	await fs.promises.rm(pluginDir, {
+		recursive: true,
+		force: true
+	});
+	task.logs.push("插件目录已删除");
+	/** 清理依赖缓存 */
+	task.logs.push("正在清理依赖缓存...");
+	await spawnCommand("pnpm", ["install", "-P"], task);
+};
+/**
+* 执行插件卸载任务
+* @param task 任务
+*/
+const uninstallPluginTask = async (task) => {
+	try {
+		task.status = "running";
+		task.logs.push(`开始卸载插件: ${task.name}`);
+		task.logs.push(`插件类型: ${task.type}`);
+		task.logs.push("-------------------");
+		switch (task.type) {
+			case "npm":
+				await uninstallNpmPlugin(task);
+				break;
+			case "git":
+				await uninstallGitPlugin(task);
+				break;
+			default: throw new Error("不支持卸载该类型的插件");
+		}
+		task.logs.push("-------------------");
+		task.logs.push("🎉 卸载完成!");
+		task.logs.push("⚠️ 建议重启 Bot 以使更改生效");
+		task.status = "completed";
+		/** 清除插件列表缓存 */
+		await deletePluginListCache();
+	} catch (error) {
+		task.status = "failed";
+		task.error = error.message;
+		task.logs.push("-------------------");
+		task.logs.push(`❌ 卸载失败: ${error.message}`);
+		throw error;
+	}
+};
+/**
+* 卸载插件
+*/
+const pluginUninstall = async (req, res) => {
+	try {
+		const { name, type } = req.body;
+		const taskId = `uninstall-${type}-${name}-${Date.now()}`;
+		if (Array.from(taskQueue.values()).find((task) => task.name === name && task.status === "running")) return createServerErrorResponse(res, "该插件正在卸载中");
+		/** 创建新任务 */
+		const task = {
+			id: taskId,
+			name,
+			type,
+			status: "pending",
+			logs: [],
+			minimized: false
+		};
+		taskQueue.set(taskId, task);
+		/** 异步执行卸载 */
+		uninstallPluginTask(task).catch((error) => {
+			task.status = "failed";
+			task.error = error.message;
+			task.logs.push(`卸载失败: ${error.message}`);
+		});
+		createSuccessResponse(res, { taskId });
+	} catch (error) {
+		createServerErrorResponse(res, error.message);
+		logger.error(error);
+	}
+};
+/**
+* 获取任务状态
+*/
+const pluginGetTaskStatus = (req, res) => {
+	try {
+		const { taskId } = req.body;
+		const task = taskQueue.get(taskId);
+		if (!task) return createServerErrorResponse(res, "任务不存在");
+		createSuccessResponse(res, task);
+	} catch (error) {
+		createServerErrorResponse(res, error.message);
+		logger.error(error);
+	}
+};
+/** 清理已完成的任务（保留作为备用清理机制） */
+const cleanupTasks = () => {
+	const THIRTY_MINUTES = 1800 * 1e3;
+	for (const [taskId, task] of taskQueue.entries()) if ((task.status === "completed" || task.status === "failed") && Date.now() - parseInt(taskId.split("-").pop() || "0") > THIRTY_MINUTES) taskQueue.delete(taskId);
+};
+/**
+* 获取任务列表
+*/
+const pluginGetTaskList = (_req, res) => {
+	/** 清理过期任务 */
+	cleanupTasks();
+	createSuccessResponse(res, Array.from(taskQueue.values()));
+};
+/**
+* 更新任务状态（最小化/恢复）
+*/
+const pluginUpdateTaskStatus = (req, res) => {
+	try {
+		const { taskId, minimized } = req.body;
+		const task = taskQueue.get(taskId);
+		if (!task) return createServerErrorResponse(res, "任务不存在");
+		task.minimized = minimized;
+		createSuccessResponse(res, task);
+	} catch (error) {
+		createServerErrorResponse(res, error.message);
+		logger.error(error);
+	}
+};
+
+//#endregion
+//#region src/server/pty/index.ts
+/**
+* 创建终端
+* @param req 请求
+* @param res 响应
+*/
+const createTerminalHandler = async (req, res) => {
+	try {
+		const { cols, rows, shell, name } = req.body;
+		const { id } = await createTerminal(name, shell, cols, rows);
+		return createSuccessResponse(res, { id });
+	} catch (error) {
+		logger.error(`[terminal] 创建终端失败: ${req.body.shell}`);
+		logger.error(error);
+		return createServerErrorResponse(res, `创建终端失败: ${error.message}`);
+	}
+};
+/**
+* 获取终端列表
+* @param _ 请求
+* @param res 响应
+*/
+const getTerminalListHandler = (_, res) => {
+	try {
+		return createSuccessResponse(res, getTerminalList());
+	} catch (error) {
+		logger.error("[terminal] 获取终端列表失败");
+		logger.error(error);
+		return createServerErrorResponse(res, `获取终端列表失败: ${error.message}`);
+	}
+};
+/**
+* 关闭终端
+* @param req 请求
+* @param res 响应
+*/
+const closeTerminalHandler = (req, res) => {
+	try {
+		const id = req.body.id;
+		if (!id) return createServerErrorResponse(res, "ID不能为空");
+		closeTerminal(id);
+		return createSuccessResponse(res, {});
+	} catch (error) {
+		logger.error(`[terminal] 关闭终端失败: ${req.body.id}`);
+		logger.error(error);
+		return createServerErrorResponse(res, `关闭终端失败: ${error.message}`);
+	}
+};
+
+//#endregion
+//#region src/server/system/check.ts
+/**
+* 检查是否安装了指定的npm包
+*/
+const checkPlugin = async (req, res) => {
+	try {
+		await import(req.body.name);
+		return createSuccessResponse(res, { installed: true }, "已安装");
+	} catch {
+		return createSuccessResponse(res, { installed: false }, "未安装");
+	}
+};
+
+//#endregion
+//#region src/server/plugins/webui.ts
+/** 版本缓存对象，键为插件名，值为缓存数据和时间戳 */
+const versionCache = {};
+/** 缓存有效期（毫秒） */
+const CACHE_TTL$1 = 120 * 1e3;
+/**
+* 插件列表
+*/
+const plugins = [{
+	name: "@karinjs/node-pty",
+	installed: false,
+	description: "提供终端功能支持，允许您在WebUI中使用命令行终端。需要注意，此插件存在风险，安装后可运行一切命令。"
+}, {
+	name: "@karinjs/plugin-webui-network-monitor",
+	installed: false,
+	description: "网络监控插件，提供网络流量、连接等监控功能，可视化展示系统网络状态。"
+}];
+/**
+* 安装webui插件
+*/
+const installWebui = async (req, res) => {
+	try {
+		const { name } = req.body;
+		if (!name) return createServerErrorResponse(res, "name不能为空");
+		if (!plugins.some((p) => p.name === name)) return createServerErrorResponse(res, "非法插件");
+		const result = await exec$3(`pnpm install ${name}${isWorkspace() ? " -w" : ""}`);
+		if (name === "@karinjs/node-pty") await initialize();
+		if (result.error) logger.error(new Error(`安装webui插件发生错误: ${name}`, { cause: result.error }));
+		logger.mark(`[webui] 安装 ${name} 插件成功`);
+		return createSuccessResponse(res, {
+			status: result.status,
+			data: result.status ? "安装成功" : result.error?.message || "安装失败"
+		});
+	} catch (error) {
+		logger.error(`[webui] 安装webui插件失败: ${req.body.name}`);
+		logger.error(error);
+		return createServerErrorResponse(res, `安装webui插件失败: ${error.message}`);
+	}
+};
+/**
+* 卸载webui插件
+*/
+const uninstallWebui = async (req, res) => {
+	try {
+		const { name } = req.body;
+		if (!name) return createServerErrorResponse(res, "name不能为空");
+		if (!plugins.some((p) => p.name === name)) return createServerErrorResponse(res, "非法插件");
+		const result = await exec$3(`pnpm uninstall ${name}`);
+		logger.mark(`[webui] 卸载 ${name} 插件成功`);
+		return createSuccessResponse(res, {
+			status: result.status,
+			data: result.status ? "卸载成功" : result.error?.message || "卸载失败"
+		});
+	} catch (error) {
+		logger.error(`[webui] 卸载webui插件失败: ${req.body.name}`);
+		logger.error(error);
+		return createServerErrorResponse(res, `卸载webui插件失败: ${error.message}`);
+	}
+};
+/**
+* 获取webui插件列表
+*/
+const getWebuiPluginList = async (_, res) => {
+	try {
+		const pkg = JSON.parse(fs.readFileSync(path.join(process.cwd(), "package.json"), "utf-8"));
+		return createSuccessResponse(res, plugins.map((plugin) => {
+			const version = pkg.dependencies?.[plugin.name] || pkg.devDependencies?.[plugin.name] || pkg.peerDependencies?.[plugin.name] || null;
+			return {
+				...plugin,
+				installed: typeof version === "string",
+				version
+			};
+		}));
+	} catch (error) {
+		logger.error("[webui] 获取插件列表失败");
+		logger.error(error);
+		return createServerErrorResponse(res, `获取插件列表失败: ${error.message}`);
+	}
+};
+/**
+* 获取WebUI插件可用版本
+*/
+const getWebuiPluginVersions = async (req, res) => {
+	try {
+		const { name } = req.body;
+		if (!name) return createServerErrorResponse(res, "name不能为空");
+		if (!plugins.some((p) => p.name === name)) return createServerErrorResponse(res, "非法插件");
+		const now = Date.now();
+		const cachedData = versionCache[name];
+		if (cachedData && now - cachedData.timestamp < CACHE_TTL$1) {
+			logger.debug(`[webui] 使用缓存的版本信息: ${name}`);
+			return createSuccessResponse(res, cachedData.data);
+		}
+		/**
+		* 获取当前安装的版本（如果已安装）
+		*/
+		let currentVersion = null;
+		const pkgPath = path.join(process.cwd(), "node_modules", name, "package.json");
+		if (fs.existsSync(pkgPath)) try {
+			const pkgContent = fs.readFileSync(pkgPath, "utf-8");
+			currentVersion = JSON.parse(pkgContent).version;
+		} catch (error) {
+			logger.error(`[webui] 读取插件版本失败: ${name}`);
+		}
+		/**
+		* 从npm获取可用版本
+		*/
+		logger.info(`[webui] 获取插件 ${name} 的版本信息`);
+		const result = await exec$3(`npm view ${name} versions --json`);
+		if (!result.status) return createServerErrorResponse(res, `获取版本信息失败: ${result.error?.message}`);
+		try {
+			let versions = JSON.parse(result.stdout);
+			versions = Array.isArray(versions) ? versions : [versions];
+			/** 反转数组，让最新版本排在前面 */
+			versions.reverse();
+			/** 限制返回的版本数量为20个 */
+			const limitedVersions = versions.slice(0, 20);
+			const responseData = {
+				currentVersion,
+				availableVersions: limitedVersions,
+				hasMoreVersions: versions.length > 20
+			};
+			versionCache[name] = {
+				data: responseData,
+				timestamp: now
+			};
+			return createSuccessResponse(res, responseData);
+		} catch (error) {
+			return createServerErrorResponse(res, `解析版本信息失败: ${error.message}`);
+		}
+	} catch (error) {
+		logger.error(`[webui] 获取插件版本失败: ${req.body.name}`);
+		logger.error(error);
+		return createServerErrorResponse(res, `获取插件版本失败: ${error.message}`);
+	}
+};
+/**
+* 更新WebUI插件到指定版本
+*/
+const updateWebuiPluginVersion = async (req, res) => {
+	try {
+		const { name, version } = req.body;
+		if (!name || !version) return createServerErrorResponse(res, "name和version不能为空");
+		if (!plugins.some((p) => p.name === name)) return createServerErrorResponse(res, "非法插件");
+		const result = await exec$3(`pnpm install ${name}@${version}${isWorkspace() ? " -w" : ""}`);
+		return createSuccessResponse(res, {
+			status: result.status,
+			data: result.status ? "更新成功" : result.error?.message || "更新失败"
+		});
+	} catch (error) {
+		logger.error(`[webui] 更新插件版本失败: ${req.body.name}@${req.body.version}`);
+		logger.error(error);
+		return createServerErrorResponse(res, `更新插件版本失败: ${error.message}`);
+	}
+};
+
+//#endregion
+//#region src/server/plugins/admin/tool.ts
+/**
+* 验证插件请求基本参数
+*
+* 检查插件操作请求的必要参数是否有效：
+* 1. 验证名称和目标不为空
+* 2. 验证插件类型是否在允许的类型列表中
+*
+* @param res - 响应对象，用于返回错误信息
+* @param name - 插件名称
+* @param target - 插件目标
+* @param pluginType - 插件类型 (npm/git/app)
+* @param allowedTypes - 允许的插件类型列表
+* @returns 验证是否通过
+*/
+const validatePluginRequest = (res, name, target, pluginType, allowedTypes) => {
+	if (!name || !target) {
+		createBadRequestResponse(res, "无效请求: 插件名称或任务名称不能为空");
+		return false;
+	}
+	if (!allowedTypes.includes(pluginType)) {
+		createBadRequestResponse(res, "无效请求: 插件类型错误");
+		return false;
+	}
+	return true;
+};
+/**
+* 启动命令子进程
+*
+* 创建一个子进程来执行指定的命令，并通过回调函数处理输出。
+* 处理标准输出、标准错误、进程结束和错误事件。
+*
+* @param command - 要执行的命令（如'npm'、'git'）
+* @param args - 命令参数数组
+* @param options - 进程选项，包括工作目录和环境变量
+* @param emitLog - 日志回调函数，用于处理进程的输出信息
+* @returns 创建的子进程对象
+*/
+const spawnProcess = (command, args, options = {}, emitLog, pnpm) => {
+	return new Promise((resolve) => {
+		const proc = spawn(command, args, {
+			shell: true,
+			cwd: options.cwd || process.cwd(),
+			env: {
+				...process.env,
+				...options.env
+			}
+		});
+		proc.stdout.on("data", (data) => {
+			const message = data.toString();
+			logger.debug(message);
+			emitLog(message);
+		});
+		proc.stderr.on("data", (data) => {
+			const message = data.toString();
+			if (message.includes("ERR_PNPM_PUBLIC_HOIST_PATTERN_DIFF")) pnpm && pnpm();
+			logger.debug(message);
+			emitLog(message);
+		});
+		proc.on("close", (code) => {
+			proc.kill();
+			emitLog(`执行完成，退出码: ${code}`);
+			resolve(true);
+		});
+		proc.on("error", (error) => {
+			logger.debug(error);
+			emitLog(`执行失败: ${error.message}`);
+			logger.error(error);
+			resolve(error);
+		});
+		return proc;
+	});
+};
+/**
+* 处理安装、更新依赖响应
+* @description 安装、更新依赖接口只允许返回200响应
+* @param res - 响应对象
+* @param success - 是否成功
+* @param message - 消息
+* @param taskId - 任务ID
+* @returns 操作响应
+*/
+const handleReturn = (res, success, message, taskId) => {
+	if (taskId) return createSuccessResponse(res, {
+		success,
+		message,
+		taskId
+	});
+	return createSuccessResponse(res, {
+		success,
+		message
+	});
+};
+
+//#endregion
+//#region src/server/plugins/admin/update.ts
+/**
+* 更新插件
+*
+* 负责处理插件更新请求，支持两种更新模式：
+* 1. 更新所有插件 (isAll=true)
+* 2. 更新单个指定插件
+*
+* 更新过程：
+* 1. 验证请求参数
+* 2. 处理全部更新或单个更新逻辑
+* 3. 创建并启动更新任务
+* 4. 返回任务ID和操作结果
+*
+* @param res - 响应对象
+* @param data - 更新数据，包含插件名称、目标、类型等
+* @param ip - 操作者IP地址
+* @returns 操作响应
+*/
+const update = async (res, data, ip = "0.0.0.0") => {
+	if (!Array.isArray(data.target) || data.target.length < 1 && !data.isAll) return handleReturn(res, false, "无效请求: 插件目标错误");
+	/** 更新全部插件 */
+	if (data.isAll) return handleReturn(res, true, "更新任务已创建，请通过taskId执行任务", await taskSystem.add({
+		type: "update",
+		name: data.name,
+		target: "all",
+		operatorIp: ip
+	}, async (options, emitLog) => {
+		await updateAll(options, emitLog, data.isAll);
+		await taskSystem.update.logs(options.id, "任务执行成功");
+		return true;
+	}));
+	const performUpdate = async (_, log) => {
+		const npm = [];
+		const git = [];
+		/** 记录不存在的插件 */
+		const notExist = [];
+		const list = await getPlugins("all", false, true);
+		for (const item of data.target) {
+			if (item.type === "npm") {
+				list.includes(`${item.type}:${item.name}`) ? npm.push({
+					name: item.name,
+					version: item.version || "latest"
+				}) : notExist.push(item.name);
+				continue;
+			}
+			if (item.type === "git") {
+				const force = typeof item.force === "boolean" ? item.force : false;
+				list.includes(`${item.type}:${item.name}`) ? git.push({
+					name: item.name,
+					version: item.version || "latest",
+					force
+				}) : notExist.push(item.name);
+				continue;
+			}
+			notExist.push(item.name);
+		}
+		if (npm.length > 0) await spawnProcess("pnpm", [
+			"update",
+			...npm.map((item) => `${item.name}@${item.version}`),
+			"--save"
+		], { timeout: 60 * 1e3 }, log);
+		for (const item of git) {
+			const { name, force } = item;
+			const result = await gitPull(path.join(karinPathPlugins, name), {
+				force,
+				timeout: 60 * 1e3
+			});
+			if (result.status) log(`更新 ${name}(git) 插件成功: ${result.hash.before} -> ${result.hash.after}`);
+			else log(`更新 ${name}(git) 插件失败: ${result.data}`);
+		}
+		return true;
+	};
+	return handleReturn(res, true, "更新任务已创建，请通过taskId执行任务", await taskSystem.add({
+		type: "update",
+		name: data.name,
+		target: data.target.map((item) => `${item.type}:${item.name}`).join(","),
+		operatorIp: ip
+	}, async (options, emitLog) => {
+		try {
+			await performUpdate(options, emitLog);
+			await taskSystem.update.logs(options.id, "任务执行成功");
+			return true;
+		} catch (error) {
+			await taskSystem.update.logs(options.id, `任务执行失败: ${error.message}`);
+			return false;
+		}
+	}));
+};
+/**
+* 更新全部插件
+*
+* 同时更新所有npm和git类型的插件：
+* 1. 获取所有插件列表并按类型分类
+* 2. 对npm插件执行批量更新
+* 3. 对git插件逐个执行更新
+* 4. 记录更新过程的日志
+*
+* @param _ - 任务参数，包含任务ID和相关信息
+* @param log - 日志函数，用于记录更新进度和结果
+* @returns 操作是否成功
+*/
+const updateAll = async (_, log, options) => {
+	/**
+	* 将插件列表按类型分类
+	* @returns 分类后的插件列表 {npm: string[], git: string[]}
+	*/
+	const categorizePlugins = async () => {
+		const list = await getPlugins("all", true, true);
+		const git = [];
+		const npm = ["node-karin"];
+		for (const item of list) if (item.type === "npm") npm.push(item.name);
+		else if (item.type === "git") git.push(item.name);
+		return {
+			npm,
+			git
+		};
+	};
+	/**
+	* 更新所有NPM插件
+	* @param npmPlugins - NPM插件列表
+	*/
+	const updateNpmPlugins = async (npmPlugins) => {
+		if (npmPlugins.length === 0) return;
+		log(`* 开始更新NPM插件，共${npmPlugins.length}个`);
+		const args = [
+			"update",
+			npmPlugins.join("@latest "),
+			"--save"
+		];
+		if (isWorkspace()) args.push("-w");
+		await spawnProcess("pnpm", args, {}, log);
+	};
+	/**
+	* 更新单个Git插件
+	* @param pluginName - 插件名称
+	* @returns 更新结果的日志消息
+	*/
+	const updateGitPlugin = async (pluginName) => {
+		const result = await gitPull(path.join(karinPathPlugins, pluginName), {
+			force: options?.force,
+			timeout: 60 * 1e3
+		});
+		if (result.status) return `更新 ${pluginName}(git) 插件成功: ${result.hash.before} -> ${result.hash.after}`;
+		return `更新 ${pluginName}(git) 插件失败: ${result.data}`;
+	};
+	/**
+	* 更新所有Git插件
+	* @param gitPlugins - Git插件列表
+	*/
+	const updateGitPlugins = async (gitPlugins) => {
+		if (gitPlugins.length === 0) return;
+		log(`* 开始更新Git插件，共${gitPlugins.length}个`);
+		for (const item of gitPlugins) log(await updateGitPlugin(item));
+		log("全部git插件更新完成");
+	};
+	const { npm, git } = await categorizePlugins();
+	try {
+		await updateNpmPlugins(npm);
+		await updateGitPlugins(git);
+	} catch (error) {
+		log(`* 发生错误: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return true;
+};
+
+//#endregion
+//#region src/plugin/system/market.ts
+/** 插件源地址列表 */
+const PLUGIN_SOURCES = [
+	"https://registry.npmmirror.com/@karinjs/plugins-list/latest",
+	"https://registry.npmjs.com/@karinjs/plugins-list/latest",
+	"https://mirrors.cloud.tencent.com/npm/@karinjs/plugins-list/latest"
+];
+/** 缓存有效期 默认12小时 */
+const CACHE_TTL = process.env.PLUGIN_MARKET_CACHE_TTL ? Number(process.env.PLUGIN_MARKET_CACHE_TTL) : 720 * 60;
+/**
+* 获取插件市场
+* @param forceUpdate - 是否强制从远程获取，忽略缓存
+* @returns 返回最先成功响应的插件列表
+*/
+const getPluginMarket = async (forceUpdate = false) => {
+	const { redis } = await import("./redis-aLJ7wbJH.mjs").then((n) => n.r);
+	if (!forceUpdate) {
+		const cachedData = await redis.get(REDIS_PLUGIN_LIST_CACHE_KEY);
+		if (cachedData) {
+			const data = JSON.parse(cachedData);
+			if (data) return data;
+		}
+	}
+	const results = await raceRequest(PLUGIN_SOURCES, { method: "get" });
+	if (!results) throw new Error("无法从任何源获取插件列表");
+	await redis.set(REDIS_PLUGIN_LIST_CACHE_KEY, JSON.stringify(results.data), { EX: CACHE_TTL });
+	logger.debug(`[插件列表] 数据已缓存，有效期${CACHE_TTL}秒`);
+	return results.data;
+};
+
+//#endregion
+//#region src/server/plugins/admin/installMarket.ts
+/**
+* 插件市场安装
+* @param res - 响应对象
+* @param data - 安装数据，包含插件名称、目标、类型等
+* @param ip - 操作者IP地址
+* @returns 操作响应
+*/
+const installMarket = async (res, data, ip) => {
+	const plugin = (await getPluginMarket(true)).plugins.find((item) => item.name === data.target);
+	if (!plugin) return handleReturn(res, false, "插件包不存在");
+	if (data.pluginType === "app" && plugin.type === "app") return installApp$1(res, plugin, data, ip);
+	if (data.pluginType === "npm" && plugin.type === "npm") {
+		if (Array.isArray(plugin.allowBuild) && plugin.allowBuild.length) data.allowBuild = plugin.allowBuild;
+		return installNpm$1(res, plugin, data, ip);
+	}
+	if (data.pluginType === "git" && plugin.type === "git") return installGit$1(res, plugin, data, ip);
+};
+/**
+* 插件市场 安装NPM类型的插件
+* @param res - 响应对象
+* @param plugin - 插件信息
+* @param data - 安装数据，包含插件名称、目标、类型等
+* @param ip - 操作者IP地址
+* @returns 操作响应
+*/
+const installNpm$1 = async (res, _, data, ip) => {
+	return handleReturn(res, true, "安装任务已创建，请通过taskId执行任务", await taskSystem.add({
+		type: "install",
+		name: data.name,
+		target: data.target,
+		operatorIp: ip
+	}, async (_, emitLog) => {
+		const args = [
+			"add",
+			data.target,
+			"--save"
+		];
+		if (isWorkspace()) args.push("-w");
+		if (Array.isArray(data.allowBuild) && data.allowBuild.length && isPnpm10()) data.allowBuild.forEach((pkg) => args.unshift(`--allow-build=${pkg}`));
+		/** 处理 ERR_PNPM_PUBLIC_HOIST_PATTERN_DIFF 错误 */
+		let IS_ERR_PNPM_PUBLIC_HOIST_PATTERN_DIFF = false;
+		await spawnProcess("pnpm", args, {}, emitLog, () => {
+			IS_ERR_PNPM_PUBLIC_HOIST_PATTERN_DIFF = true;
+		});
+		if (IS_ERR_PNPM_PUBLIC_HOIST_PATTERN_DIFF) {
+			emitLog("检测到 ERR_PNPM_PUBLIC_HOIST_PATTERN_DIFF 错误，尝试修复...");
+			emitLog("执行 pnpm install -f 强制重建模块目录");
+			/** 先执行 pnpm install -f 强制重建模块目录 */
+			await spawnProcess("pnpm", ["install", "-f"], {}, emitLog);
+			emitLog("模块目录重建完成，重新尝试安装插件");
+			/** 重新尝试安装 */
+			await spawnProcess("pnpm", args, {}, emitLog);
+			emitLog("安装完成，尝试加载插件");
+		}
+		await pkgHotReload("npm", data.target);
+		return true;
+	}));
+};
+/**
+* 插件市场 安装Git类型的插件
+* @param res - 响应对象
+* @param plugin - 插件信息
+* @param data - 安装数据，包含插件名称、目标、类型等
+* @param ip - 操作者IP地址
+* @returns 操作响应
+*/
+const installGit$1 = async (res, plugin, data, ip) => {
+	/** 竞速 */
+	const urls = [];
+	plugin.repo.forEach((v) => {
+		if (!v.type.includes("git")) return;
+		urls.push(v.url);
+	});
+	const repo = await raceRequest(urls, {
+		method: "HEAD",
+		timeout: 5e3
+	});
+	if (repo?.status !== 200) return handleReturn(res, false, "测试访问仓库失败，请检查当前网络环境是否正常");
+	return handleReturn(res, true, "安装任务已创建，请通过taskId执行任务", await taskSystem.add({
+		type: "install",
+		name: data.name,
+		target: data.target,
+		operatorIp: ip
+	}, async (_, emitLog) => {
+		await spawnProcess("git", [
+			"clone",
+			"--depth=1",
+			repo.config.url,
+			`./plugins/${plugin.name}`
+		], {}, emitLog);
+		await pkgHotReload("git", plugin.name);
+		return true;
+	}));
+};
+/**
+* 插件市场 安装app类型的插件
+* @param res - 响应对象
+* @param plugin - 插件信息
+* @param data - 安装数据，包含插件名称、目标、类型等
+* @param ip - 操作者IP地址
+* @returns 操作响应
+*/
+const installApp$1 = async (res, plugin, data, ip) => {
+	if (!data.urls || !Array.isArray(data.urls)) return handleReturn(res, false, "app插件名称不能为空");
+	/** 排除掉files中 不存在插件市场的文件 */
+	let urls = plugin.files.filter((item) => data.urls.includes(item.url));
+	if (!urls.length) return handleReturn(res, false, "请传递正确的app插件名称");
+	let isRace = false;
+	/** 对每个url进行判断 如果是github的 竞速换源 */
+	for (const app of urls) if (app.url.startsWith("https://raw.githubusercontent.com")) {
+		isRace = true;
+		break;
+	}
+	if (isRace) {
+		const result = await getFastGithub("raw");
+		urls = urls.map((item) => {
+			return {
+				...item,
+				url: item.url.startsWith("https://raw.githubusercontent.com") ? result.raw(item.url) : item.url
+			};
+		});
+	}
+	return handleReturn(res, true, "安装任务已创建，请通过taskId执行任务", await taskSystem.add({
+		type: "install",
+		name: data.name,
+		target: data.target,
+		operatorIp: ip
+	}, async (_, emitLog) => {
+		const msg = ["安装任务执行中"];
+		/** 插件目录 统一下载到这里方便管理 */
+		const dir = path.join(karinPathPlugins, "karin-plugin-example");
+		mkdirSync(dir);
+		emitLog("开始下载插件文件...");
+		await Promise.all(urls.map(async (app) => {
+			const filename = path.basename(app.url);
+			const fileUrl = path.join(dir, filename);
+			emitLog(`正在下载: ${filename}`);
+			const result = await downloadFile(app.url, fileUrl);
+			if (!result.success) {
+				let err = `${filename} 下载失败: `;
+				if (result.data instanceof AxiosError) err += result.data.message;
+				else if (result.data instanceof Error) err += result.data.message || result.data.stack || "未知错误";
+				else err += String(result.data);
+				logger.error(`[install] 下载app插件失败:\n  url: ${app.url}\n  message: ${err}`);
+				msg.push(err);
+				emitLog(err);
+				return;
+			}
+			msg.push(`${app.url} 下载成功`);
+			emitLog(`${app.url} 下载成功`);
+		}));
+		emitLog("安装完成");
+		return true;
+	}));
+};
+
+//#endregion
+//#region src/server/plugins/admin/installCustom.ts
+/**
+* 自定义安装
+* @param res - 响应对象
+* @param data - 安装数据，包含插件名称、目标、类型等
+* @param ip - 操作者IP地址
+* @returns 操作响应
+*/
+const installCustom = async (res, data, ip) => {
+	if (data.pluginType === "app") return installApp(res, data, ip);
+	if (data.pluginType === "npm") return installNpm(res, data, ip);
+	if (data.pluginType === "git") return installGit(res, data, ip);
+};
+/**
+* 自定义安装NPM类型的插件
+* @param res - 响应对象
+* @param data - 安装数据，包含插件名称、目标、类型等
+* @param ip - 操作者IP地址
+* @returns 操作响应
+*/
+const installNpm = async (res, data, ip) => {
+	return handleReturn(res, true, "安装任务已创建，请通过taskId执行任务", await taskSystem.add({
+		type: "install",
+		name: data.name,
+		target: data.target,
+		operatorIp: ip
+	}, async (_, emitLog) => {
+		/** 包名 */
+		let pkg = data.target;
+		/** 自定义版本版本 */
+		if (data.version) pkg += `@${data.version}`;
+		const args = [
+			"add",
+			pkg,
+			"--save"
+		];
+		if (isWorkspace()) args.push("-w");
+		if (data.registry) args.push(`--registry=${data.registry}`);
+		if (Array.isArray(data.allowBuild) && data.allowBuild.length && isPnpm10()) data.allowBuild.forEach((pkg) => args.unshift(`--allow-build=${pkg}`));
+		/** 处理 ERR_PNPM_PUBLIC_HOIST_PATTERN_DIFF 错误 */
+		let IS_ERR_PNPM_PUBLIC_HOIST_PATTERN_DIFF = false;
+		await spawnProcess("pnpm", args, {}, emitLog, () => {
+			IS_ERR_PNPM_PUBLIC_HOIST_PATTERN_DIFF = true;
+		});
+		if (IS_ERR_PNPM_PUBLIC_HOIST_PATTERN_DIFF) {
+			emitLog("检测到 ERR_PNPM_PUBLIC_HOIST_PATTERN_DIFF 错误，尝试修复...");
+			emitLog("执行 pnpm install -f 强制重建模块目录");
+			/** 先执行 pnpm install -f 强制重建模块目录 */
+			await spawnProcess("pnpm", ["install", "-f"], {}, emitLog);
+			emitLog("模块目录重建完成，重新尝试安装插件");
+			/** 重新尝试安装 */
+			await spawnProcess("pnpm", args, {}, emitLog);
+			emitLog("安装完成，尝试加载插件");
+		}
+		await pkgHotReload("npm", data.target);
+		return true;
+	}));
+};
+/**
+* 自定义安装Git类型的插件
+* @param res - 响应对象
+* @param data - 安装数据，包含插件名称、目标、类型等
+* @param ip - 操作者IP地址
+* @returns 操作响应
+*/
+const installGit = async (res, data, ip) => {
+	const pkgName = data.target || path.basename(data.repo).replace(".git", "");
+	if (!pkgName.startsWith("karin-plugin-")) return handleReturn(res, false, "插件名称必须以karin-plugin-开头");
+	return handleReturn(res, true, "安装任务已创建，请通过taskId执行任务", await taskSystem.add({
+		type: "install",
+		name: data.name,
+		target: data.target,
+		operatorIp: ip
+	}, async (_, emitLog) => {
+		await spawnProcess("git", [
+			data.branch ? `-b ${data.branch}` : "",
+			"clone",
+			"--depth=1",
+			data.repo,
+			`./plugins/${pkgName}`
+		], {}, emitLog);
+		await pkgHotReload("git", pkgName);
+		return true;
+	}));
+};
+/**
+* 自定义安装app类型的插件
+* @param res - 响应对象
+* @param data - 安装数据，包含插件名称、目标、类型等
+* @param ip - 操作者IP地址
+* @returns 操作响应
+*/
+const installApp = async (res, data, ip) => {
+	if (!data.jsUrl) return handleReturn(res, false, "jsUrl不能为空");
+	/** 下载后的文件名称 */
+	let filename = data.target || path.basename(data.jsUrl);
+	if (!filename.endsWith(".js")) filename += ".js";
+	return handleReturn(res, true, "安装任务已创建，请通过taskId执行任务", await taskSystem.add({
+		type: "install",
+		name: data.name,
+		target: data.target,
+		operatorIp: ip
+	}, async (_, emitLog) => {
+		/** 插件目录 统一下载到这里方便管理 */
+		const dir = path.join(karinPathPlugins, "karin-plugin-example");
+		const fileUrl = path.join(dir, filename);
+		mkdirSync(dir);
+		emitLog(`开始下载插件文件: ${filename}`);
+		const result = await downloadFile(data.jsUrl, fileUrl);
+		if (!result.success) {
+			let msg = "app插件下载失败: ";
+			if (result.data instanceof AxiosError) msg += result.data.message;
+			else if (result.data instanceof Error) msg += result.data.message || result.data.stack || "未知错误";
+			else msg += String(result.data);
+			logger.error(`[install] 下载app插件失败:\n  url: ${data.jsUrl}\n  message: ${msg}`);
+			emitLog(msg);
+			return false;
+		}
+		emitLog(`下载完成: ${data.jsUrl}`);
+		return true;
+	}));
+};
+
+//#endregion
+//#region src/server/plugins/admin/install.ts
+/**
+* 安装插件
+* @param res - 响应对象
+* @param data - 更新数据，包含插件名称、目标、类型等
+* @param ip - 操作者IP地址
+* @returns 操作响应
+*/
+const install = async (res, data, ip = "0.0.0.0") => {
+	if (!validatePluginRequest(res, data.name, data.target, data.pluginType, [
+		"npm",
+		"git",
+		"app"
+	])) return;
+	if (data.source === "market") return installMarket(res, data, ip);
+	if (data.source === "custom") return installCustom(res, data, ip);
+	return handleReturn(res, false, "无效的安装来源");
+};
+
+//#endregion
+//#region src/server/plugins/admin/uninstall.ts
+/**
+* 卸载插件
+*
+* 根据插件类型执行不同的卸载操作：
+* - npm: 使用pnpm remove命令卸载npm包
+* - git: 删除插件目录
+* - app: 删除特定的应用文件
+*
+* 过程：
+* 1. 验证请求参数
+* 2. 检查插件是否存在
+* 3. 创建并执行卸载任务
+* 4. 返回操作结果
+*
+* @param res - 响应对象
+* @param name - 插件名称
+* @param target - 插件目标
+* @param pluginType - 插件类型 (npm/git/app)
+* @param operatorIp - 操作者IP地址
+* @returns 操作响应
+*/
+const uninstall = async (res, name, target, operatorIp = "0.0.0.0") => {
+	if (!Array.isArray(target) || target.length < 1) return handleReturn(res, false, "无效请求: 插件目标错误");
+	/**
+	* 执行不同类型插件的卸载操作
+	*
+	* 根据插件类型选择适当的卸载方法：
+	* - npm包：使用pnpm remove
+	* - git仓库：删除整个目录
+	* - app应用：删除特定文件
+	*
+	* @returns 操作结果对象
+	*/
+	const performUninstall = async (emitLog) => {
+		const npm = [];
+		const git = [];
+		const app = [];
+		/** 记录不存在的插件 */
+		const notExist = [];
+		/** 本地已安装插件列表 */
+		const list = await getPlugins("all");
+		target.forEach(async (v) => {
+			if (v.type === "npm") {
+				list.includes(`${v.type}:${v.name}`) ? npm.push(v.name) : notExist.push(v.name);
+				return;
+			}
+			if (v.type === "git") {
+				list.includes(`${v.type}:${v.name}`) ? git.push(v.name) : notExist.push(v.name);
+				return;
+			}
+			if (v.type === "app") {
+				/** 等下直接判断路径更快 因为还需要判断路径穿越的问题 */
+				app.push(v.name);
+				return;
+			}
+			notExist.push(v.name);
+		});
+		await spawnProcess("pnpm", ["remove", ...npm], { timeout: 60 * 1e3 }, emitLog);
+		/** 执行完成之后 检查package.json是否还存在这些依赖 */
+		const pkg = path.join(process.cwd(), "package.json");
+		if (fs.existsSync(pkg)) {
+			const content = fs.readFileSync(pkg, "utf-8");
+			const data = JSON.parse(content);
+			const delDep = (obj) => {
+				Object.keys(obj).forEach((key) => {
+					if (npm.includes(key)) delete obj[key];
+				});
+			};
+			delDep(data.dependencies);
+			delDep(data.devDependencies);
+			delDep(data.peerDependencies);
+			fs.writeFileSync(pkg, JSON.stringify(data, null, 2), "utf-8");
+		}
+		/** tips: 不要使用异步 */
+		for (const v of git) {
+			emitLog("-----------------------");
+			emitLog(`开始卸载 git 插件: ${v}`);
+			if (v.includes("..")) {
+				emitLog(`卸载 ${v} 失败: 文件名称存在路径穿越风险`);
+				continue;
+			}
+			/** 判断git文件夹是否存在 */
+			const dir = path.join(karinPathPlugins, v);
+			if (!fs.existsSync(path.join(dir, ".git"))) {
+				emitLog(`卸载 ${v} 失败: 非git仓库`);
+				continue;
+			}
+			try {
+				await fs.promises.rm(dir, {
+					recursive: true,
+					force: true
+				});
+				emitLog(`卸载 ${v} 成功`);
+			} catch (error) {
+				emitLog(`卸载 ${v} 失败: ${error.message}`);
+			}
+			emitLog("-----------------------\n\n");
+		}
+		for (const v of app) {
+			emitLog("-----------------------");
+			emitLog(`开始卸载 app 插件: ${v}`);
+			if (v.includes("..")) {
+				emitLog(`卸载 ${v} 失败: 文件名称存在路径穿越风险`);
+				continue;
+			}
+			/** 判断app文件夹是否存在 */
+			const arr = v.split("/");
+			const [pkg, file] = arr;
+			if (arr.length !== 2 || !pkg || !file) {
+				emitLog(`卸载 ${v} 失败: 格式错误`);
+				continue;
+			}
+			if (!list.includes(`app:${pkg}`)) {
+				emitLog(`卸载 ${v} 失败: 插件不存在`);
+				continue;
+			}
+			const dir = path.join(karinPathPlugins, pkg);
+			if (!fs.existsSync(path.join(dir, file))) {
+				emitLog(`卸载 ${v} 失败: 文件不存在`);
+				continue;
+			}
+			/** 判断后缀 必须是.js .mjs .cjs .ts .cts .mts */
+			const ext = path.extname(file);
+			if (![
+				".js",
+				".mjs",
+				".cjs",
+				".ts",
+				".cts",
+				".mts"
+			].includes(ext)) {
+				emitLog(`卸载 ${v} 失败: 错误的文件类型`);
+				continue;
+			}
+			try {
+				/** 这里是文件 不能使用rm函数 */
+				await fs.promises.unlink(path.join(dir, file));
+				emitLog(`卸载 ${v} 成功`);
+			} catch (error) {
+				emitLog(`卸载 ${v} 失败: ${error.message}`);
+			}
+			emitLog("-----------------------\n\n");
+		}
+		if (notExist.length) {
+			notExist.unshift("以下插件不存在:");
+			emitLog(notExist.join("\n") + "\n\n");
+		}
+		emitLog("卸载任务完成");
+	};
+	return handleReturn(res, true, "卸载任务已创建，请通过taskId执行任务", await taskSystem.add({
+		type: "uninstall",
+		name,
+		target: target.map((v) => `${v.type}:${v.name}`).join(","),
+		operatorIp
+	}, async (options, emitLog) => {
+		try {
+			await performUninstall(emitLog);
+			await taskSystem.update.logs(options.id, "任务执行成功");
+			return true;
+		} catch (error) {
+			await taskSystem.update.logs(options.id, `任务执行失败: ${error.message}`);
+			return false;
+		}
+	}));
+};
+
+//#endregion
+//#region src/server/plugins/admin/router.ts
+/**
+* 插件管理路由
+*
+* 处理插件相关的API请求，包括：
+* - 更新插件：更新已安装的插件到最新版本
+* - 卸载插件：移除指定的插件
+* - 安装插件：安装新的插件
+*
+* @param req - 请求对象，包含插件操作类型和相关参数
+* @param res - 响应对象，用于返回操作结果
+* @returns 响应结果
+*/
+const pluginAdminRouter = (req, res) => {
+	if (req.body.type === "uninstall")
+ /**
+	* @description 此处的所有api都必须给予响应并且符合以下格式
+	* @example
+	* ```json
+	* {
+	*   "success": true,
+	*   "message": "卸载成功"
+	* }
+	*
+	* {
+	*   "success": false,
+	*   "message": "卸载失败"
+	* }
+	* ```
+	*/
+	return uninstall(res, req.body.name, req.body.target, req.ip);
+	if (req.body.type === "update")
+ /**
+	* @description 此处的所有api都必须给予响应并且符合以下格式
+	* @example
+	* ```json
+	* {
+	*   "success": true,
+	*   "message": "更新任务已创建",
+	*   "taskId": "1234567890"
+	* }
+	*
+	* {
+	*   "success": false,
+	*   "message": "更新失败"
+	* }
+	* ```
+	*/
+	return update(res, req.body, req.ip);
+	if (req.body.type !== "install") return handleReturn(res, false, "无效请求: 插件类型错误");
+	/**
+	* @description 此处的所有api都必须给予响应并且符合以下格式
+	* @example
+	* ```json
+	* {
+	*   "success": true,
+	*   "message": "安装成功"
+	* }
+	*
+	* {
+	*   "success": false,
+	*   "message": "安装失败"
+	* }
+	*
+	* {
+	*   "success": true,
+	*   "message": "安装任务已创建",
+	*   "taskId": "1234567890"
+	* }
+	* ```
+	*/
+	return install(res, req.body, req.ip);
+};
+
+//#endregion
+//#region src/utils/npm/registry.ts
+/**
+* 获取registry
+*/
+const getRegistry = async () => {
+	if (process.env.npm_config_registry) return process.env.npm_config_registry;
+	const registry = await exec$3("npm config get registry");
+	process.env.npm_config_registry = registry.stdout;
+	return registry.stdout;
+};
+/**
+* 获取一个npm包registry配置
+* @param name - 包名
+* @returns registry
+*/
+const getNpmRegistry = async (name) => {
+	/** 获取npm源 */
+	const registry = await getRegistry();
+	return (await axios.get(`${registry}/${name}`)).data;
+};
+/**
+* 获取一个npm包的最新版本
+* @param name - 包名
+* @returns 最新版本
+*/
+const getNpmLatestVersion = async (name) => {
+	try {
+		return (await getNpmRegistry(name))["dist-tags"].latest;
+	} catch (error) {
+		logger.debug(new Error(`获取${name}最新版本失败`, { cause: error }));
+		return null;
+	}
+};
+/** 初始化一下 防止并发 */
+getRegistry();
+
+//#endregion
+//#region src/server/dependencies/list.ts
+/**
+* 获取项目依赖列表
+*/
+const getDependenciesListRouter = async (req, res) => {
+	try {
+		const cache = await getCache$1(req, res);
+		if (cache) return createSuccessResponse(res, cache);
+		const { stdout, error } = await exec$3("pnpm list --depth=0 --json");
+		if (error) return createBadRequestResponse(res, error.message);
+		/** 并发请求 */
+		const promises = [];
+		/** 返回给前端的依赖列表 */
+		let list = [];
+		/** package.json */
+		const pkg = requireFileSync("./package.json", { force: true });
+		/** 当前依赖列表 */
+		const dependencies = JSON.parse(stdout);
+		/** 遍历当前依赖列表 转换格式 */
+		for (const dependency of dependencies) Object.entries(dependency).forEach(([key, value]) => {
+			if (typeof value !== "object") return;
+			Object.entries(value).forEach(([k, v]) => {
+				promises.push(getDependenciesInfo(pkg, list, k, v, key));
+			});
+		});
+		await Promise.allSettled(promises);
+		const npmPlugin = await getPlugins("npm");
+		list.forEach((item) => {
+			item.isKarinPlugin = npmPlugin.some((plugin) => plugin === `npm:${item.name}`);
+		});
+		/**
+		* 依赖类型权重映射
+		* 权重越小优先级越高
+		*/
+		const typeWeightMap = {
+			dependencies: 1,
+			devDependencies: 2,
+			peerDependencies: 3,
+			optionalDependencies: 4,
+			unsavedDependencies: 5
+		};
+		list = lodash.sortBy(list, [
+			(item) => !(item.name === "node-karin"),
+			"isKarinPlugin",
+			(item) => typeWeightMap[item.type],
+			"name"
+		]);
+		await setCache$1(list);
+		return createSuccessResponse(res, list);
+	} catch (error) {
+		logger.error("[getDependenciesListRouter]", error);
+		return createServerErrorResponse(res, error instanceof Error ? error.message : String(error));
+	}
+};
+/**
+* 获取依赖信息
+* @param pkg - 项目package.json
+* @param list - 依赖列表
+* @param key - 依赖名称
+* @param value - 依赖信息
+* @param type - 依赖类型
+*/
+const getDependenciesInfo = async (pkg, list, key, value, type) => {
+	if (!key || !value?.version) return;
+	try {
+		/** 获取版本列表 */
+		const registry = await getNpmRegistry(value.from);
+		/** 获取最新的15个版本 数组最后就是最新的版本 不足15个就返回全部 */
+		const latest = Object.keys(registry.versions).slice(-15).filter(Boolean);
+		let packageValue = "";
+		/** type以pkg中的为准 */
+		if (pkg.dependencies?.[key]) {
+			type = "dependencies";
+			packageValue = pkg.dependencies?.[key];
+		} else if (pkg.devDependencies?.[key]) {
+			type = "devDependencies";
+			packageValue = pkg.devDependencies?.[key];
+		} else if (pkg.peerDependencies?.[key]) {
+			type = "peerDependencies";
+			packageValue = pkg.peerDependencies?.[key];
+		} else if (pkg.optionalDependencies?.[key]) {
+			type = "optionalDependencies";
+			packageValue = pkg.optionalDependencies?.[key];
+		}
+		list.push({
+			name: key,
+			type,
+			from: value.from,
+			current: value.version,
+			isKarinPlugin: false,
+			latest,
+			packageValue
+		});
+	} catch (error) {
+		logger.debug(`[getDependenciesInfo] 获取${key}的版本信息失败`, error);
+	}
+};
+/**
+* 获取缓存
+* @param req - 请求
+* @param res - 响应
+*/
+const getCache$1 = async (req, _) => {
+	if (req.body?.force) return null;
+	const { redis } = await import("./redis-aLJ7wbJH.mjs").then((n) => n.r);
+	const cache = await redis.get(REDIS_DEPENDENCIES_LIST_CACHE_KEY);
+	if (cache) {
+		const data = JSON.parse(cache);
+		if (!Array.isArray(data)) {
+			await redis.del(REDIS_DEPENDENCIES_LIST_CACHE_KEY);
+			return null;
+		}
+		return data;
+	}
+	return null;
+};
+/**
+* 设置缓存
+* @param data - 依赖列表
+*/
+const setCache$1 = async (data) => {
+	const { redis } = await import("./redis-aLJ7wbJH.mjs").then((n) => n.r);
+	await redis.set(REDIS_DEPENDENCIES_LIST_CACHE_KEY, JSON.stringify(data), { EX: REDIS_DEPENDENCIES_LIST_CACHE_EXPIRE });
+};
+
+//#endregion
+//#region src/server/dependencies/manage.ts
+/**
+* 依赖管理路由
+*
+* 处理依赖相关的API请求，包括：
+* - 安装依赖：安装指定版本的依赖
+* - 删除依赖：删除指定的依赖
+*
+* @param req - 请求对象，包含操作类型和依赖参数
+* @param res - 响应对象，用于返回操作结果
+* @returns 响应结果
+*/
+const manageDependenciesRouter = async (req, res) => {
+	const { type, data } = req.body;
+	if (type === "add")
+ /**
+	* @description 此处的响应格式符合以下格式
+	* @example
+	* ```json
+	* {
+	*   "success": true,
+	*   "message": "添加任务已创建",
+	*   "taskId": "1234567890"
+	* }
+	*
+	* {
+	*   "success": false,
+	*   "message": "添加失败"
+	* }
+	* ```
+	*/
+	return await addDependencies(res, data, req.ip);
+	if (type === "upgrade")
+ /**
+	* @description 此处的响应格式符合以下格式
+	* @example
+	* ```json
+	* {
+	*   "success": true,
+	*   "message": "安装任务已创建",
+	*   "taskId": "1234567890"
+	* }
+	*
+	* {
+	*   "success": false,
+	*   "message": "安装失败"
+	* }
+	* ```
+	*/
+	return await installDependencies(res, data, req.ip);
+	if (type === "remove")
+ /**
+	* @description 此处的响应格式符合以下格式
+	* @example
+	* ```json
+	* {
+	*   "success": true,
+	*   "message": "删除任务已创建",
+	*   "taskId": "1234567890"
+	* }
+	*
+	* {
+	*   "success": false,
+	*   "message": "删除失败"
+	* }
+	* ```
+	*/
+	return await removeDependencies(res, data, req.ip);
+	return handleReturn(res, false, "无效请求：不支持的操作类型");
+};
+/**
+* 安装依赖
+*
+* @param res - 响应对象
+* @param dependencies - 依赖列表，包含名称和版本
+* @param ip - 操作者IP地址
+* @returns 操作响应
+*/
+const installDependencies = async (res, dependencies, ip) => {
+	try {
+		const packagesToInstall = dependencies.map((dep) => `${dep.name}@${dep.version || "latest"}`).join(" ");
+		return handleReturn(res, true, "安装任务已创建", await taskSystem.add({
+			type: "install-dependencies",
+			name: "安装依赖",
+			target: packagesToInstall,
+			operatorIp: ip
+		}, async (_, emitLog) => {
+			const args = ["install", ...packagesToInstall.split(" ")];
+			if (isWorkspace()) args.push("-w");
+			await spawnProcess("pnpm", args, {}, emitLog);
+			logger.mark(`安装依赖 ${logger.green(packagesToInstall)} 完成`);
+			return true;
+		}));
+	} catch (error) {
+		logger.error("[installDependencies]", error);
+		logger.mark(`安装依赖 ${logger.red(dependencies.join(" "))} 失败`);
+		return handleReturn(res, false, `安装失败: ${error instanceof Error ? error.message : String(error)}`);
+	}
+};
+/**
+* 删除依赖
+*
+* @param res - 响应对象
+* @param dependencies - 依赖列表
+* @param ip - 操作者IP地址
+* @returns 操作响应
+*/
+const removeDependencies = async (res, dependencies, ip) => {
+	try {
+		const packagesToRemove = dependencies.join(" ");
+		return handleReturn(res, true, "删除任务已创建", await taskSystem.add({
+			type: "remove-dependencies",
+			name: "删除依赖",
+			target: packagesToRemove,
+			operatorIp: ip
+		}, async (_, emitLog) => {
+			const args = ["remove", ...packagesToRemove.split(" ")];
+			if (isWorkspace()) args.push("-w");
+			await spawnProcess("pnpm", args, {}, emitLog);
+			logger.mark(`删除依赖 ${logger.yellow(packagesToRemove)} 完成`);
+			return true;
+		}));
+	} catch (error) {
+		logger.error("[removeDependencies]", error);
+		logger.mark(`删除依赖 ${logger.red(dependencies.join(" "))} 失败`);
+		return handleReturn(res, false, `删除失败: ${error instanceof Error ? error.message : String(error)}`);
+	}
+};
+/**
+* 添加依赖
+*
+* @param res - 响应对象
+* @param dependencies - 依赖列表
+* @param ip - 操作者IP地址
+*/
+const addDependencies = async (res, dependencies, ip) => {
+	try {
+		if (!dependencies.name || !dependencies.location) return handleReturn(res, false, "无效请求：缺少必要参数");
+		const name = `${dependencies.name}@${dependencies.version || "latest"}`;
+		return handleReturn(res, true, "添加任务已创建", await taskSystem.add({
+			type: "add-dependencies",
+			name: "依赖新增",
+			target: name,
+			operatorIp: ip
+		}, async (_, emitLog) => {
+			const args = ["add", name];
+			if (Array.isArray(dependencies.allowBuild) && dependencies.allowBuild.length && isPnpm10()) dependencies.allowBuild.forEach((pkg) => args.unshift(`--allow-build=${pkg}`));
+			if (dependencies.location === "devDependencies") args.push("-D");
+			else if (dependencies.location === "optionalDependencies") args.push("-O");
+			if (isWorkspace()) args.push("-w");
+			await spawnProcess("pnpm", args, {}, emitLog);
+			/**
+			* @version 1.9.9
+			* 如果新增的依赖存在对等依赖 需要再执行一次pnpm install
+			*/
+			const depDir = path.join(process.cwd(), "packages", dependencies.name, "package.json");
+			try {
+				if (!JSON.parse(fs.readFileSync(depDir, "utf-8")).peerDependencies) return true;
+				await spawnProcess("pnpm", ["install"], {}, emitLog);
+			} catch (error) {
+				logger.error("[addDependencies]", error);
+				emitLog(util.format(error));
+			}
+			logger.mark(`新增依赖 ${logger.green(dependencies.name)} 完成`);
+			return true;
+		}));
+	} catch (error) {
+		logger.error("[addDependencies]", error);
+		logger.mark(`新增依赖 ${logger.red(dependencies.name)} 失败`);
+		return handleReturn(res, false, `添加失败: ${error instanceof Error ? error.message : String(error)}`);
+	}
+};
+
+//#endregion
+//#region src/server/task/list.ts
+const taskStatusMap = {
+	pending: "待执行(pending)",
+	running: "执行中(running)",
+	success: "成功(success)",
+	failed: "失败(failed)",
+	canceled: "已取消(canceled)",
+	timeout: "超时(timeout)"
+};
+/** 活跃的SSE连接计数 */
+const activeConnections = /* @__PURE__ */ new Map();
+/** 最大允许的同时连接数 */
+const MAX_CONNECTIONS = 3;
+/**
+* 获取任务列表
+*/
+const taskListRouter = async (_req, res) => {
+	createSuccessResponse(res, await taskSystem.list());
+};
+/**
+* 执行任务
+* 返回SSE长连接，实时推送任务执行日志和状态
+*/
+const taskRunRouter = async (req, res) => {
+	const id = req.query.id;
+	const lastIndex = req.query.lastIndex;
+	if (typeof id !== "string" || id.length === 0) return createServerErrorResponse(res, "id 为空");
+	const task = await taskSystem.get(id);
+	if (!task) return createServerErrorResponse(res, "任务不存在");
+	/** 获取当前活跃连接总数 */
+	const totalConnections = [...activeConnections.values()].reduce((sum, connection) => sum + connection.count, 0);
+	/** 如果不是断线重连并且超过最大连接数，则拒绝新连接 */
+	if (!lastIndex && totalConnections >= MAX_CONNECTIONS) return createServerErrorResponse(res, `服务器负载过高，当前连接数已达上限(${MAX_CONNECTIONS})，请稍后重试`);
+	/** 检查任务是否存在 */
+	if (await taskSystem.exists(task.type, task.target, ["running"])) return createServerErrorResponse(res, "已有相同任务正在执行，请勿重复创建任务...");
+	try {
+		/** 设置SSE响应头 */
+		res.setHeader("Content-Type", "text/event-stream");
+		/** 设置缓存为不缓存 */
+		res.setHeader("Cache-Control", "no-cache");
+		/** 设置连接为长连接 */
+		res.setHeader("Connection", "keep-alive");
+		/** 立即发送响应头 */
+		res.flushHeaders();
+		/** 获取或初始化任务连接信息 */
+		if (!activeConnections.has(id)) activeConnections.set(id, {
+			count: 0,
+			logs: [],
+			status: task.status
+		});
+		/** 更新连接计数 */
+		const connectionInfo = activeConnections.get(id);
+		connectionInfo.count++;
+		/** 如果是重连请求，先发送之前缓存的日志 */
+		if (lastIndex && connectionInfo.logs.length > 0) {
+			const lastPos = parseInt(lastIndex, 10) || 0;
+			if (lastPos < connectionInfo.logs.length) connectionInfo.logs.slice(lastPos).forEach((log) => res.write(`data: ${log}\n\n`));
+		} else res.write("data: 任务创建成功: 开始执行...\n\n");
+		/** sse是否处于运行状态 */
+		let sseOpen = true;
+		req.on("close", () => {
+			sseOpen = false;
+			/** 更新连接计数 */
+			if (activeConnections.has(id)) {
+				const info = activeConnections.get(id);
+				info.count = Math.max(0, info.count - 1);
+				/** 如果没有活跃连接且任务已完成，清理缓存 */
+				if (info.count === 0 && info.status !== "running" && info.status !== "pending") activeConnections.delete(id);
+			}
+			logger.debug(`[task][${id}] 客户端断开连接，当前连接数: ${activeConnections.get(id)?.count || 0}`);
+		});
+		taskSystem.run(id, (log) => {
+			/** 缓存日志 */
+			if (activeConnections.has(id)) activeConnections.get(id).logs.push(log);
+			/** 发送日志到客户端 */
+			sseOpen && res.write(`data: ${log}\n\n`);
+		}, (status) => {
+			const tips = taskStatusMap[status];
+			logger.debug(`[task][${id}] 状态变更: ${tips}`);
+			/** 更新任务状态 */
+			if (activeConnections.has(id)) activeConnections.get(id).status = status;
+			if (!sseOpen) {
+				logger.debug(`[task][${id}] sse已关闭 停止发送日志`);
+				return;
+			}
+			res.write(`data: 任务状态变更: ${tips}\n\n`);
+			if (status !== "running" && status !== "pending") {
+				res.write("data: 任务执行完成，结束连接\n\n");
+				res.end("data: end\n\n");
+				/** 如果没有活跃连接，清理缓存 */
+				if (activeConnections.has(id) && activeConnections.get(id).count <= 1) activeConnections.delete(id);
+			}
+		});
+	} catch (error) {
+		/** 更新连接计数 */
+		if (activeConnections.has(id)) activeConnections.get(id).count = Math.max(0, activeConnections.get(id).count - 1);
+		if (res.headersSent) {
+			res.write(`data: ${error instanceof Error ? error.message : String(error)} \n\n`);
+			res.end("data: end\n\n");
+			return;
+		}
+		createServerErrorResponse(res, error instanceof Error ? error.message : String(error));
+	}
+};
+/**
+* 获取任务日志
+* 根据任务状态提供不同的响应:
+* - 任务运行中: 返回SSE长连接实时获取日志
+* - 任务已完成: 直接返回完整日志
+*/
+const taskLogsRouter = async (req, res) => {
+	const { id } = req.params;
+	if (!id || typeof id !== "string" || id.length === 0) return createServerErrorResponse(res, "任务ID不能为空");
+	try {
+		const task = await taskSystem.get(id);
+		if (!task) return createServerErrorResponse(res, "任务不存在");
+		/** 任务非运行中或非待执行，直接返回日志 */
+		if (task.status === "running" || task.status === "pending") return createSuccessResponse(res, { logs: await taskSystem.logs(id) || "" });
+		/** 设置SSE响应头 */
+		res.setHeader("Content-Type", "text/event-stream");
+		res.setHeader("Cache-Control", "no-cache");
+		res.setHeader("Connection", "keep-alive");
+		res.flushHeaders();
+		/** sse是否处于运行状态 */
+		let sseOpen = true;
+		let timer = null;
+		req.on("close", () => {
+			sseOpen = false;
+			timer && clearInterval(timer);
+			logger.debug(`[task][${id}] sse已关闭 停止发送日志`);
+		});
+		res.write(`data: ${[
+			`当前状态: ${taskStatusMap[task.status]}`,
+			`ID: ${task.id}`,
+			`名称: ${task.name}`,
+			`类型: ${task.type}`,
+			`目标: ${task.target}`,
+			`创建时间: ${task.createTime}`,
+			`更新时间: ${task.updateTime}`
+		].join("\n")} \n\n`);
+		timer = setInterval(async () => {
+			try {
+				const info = await taskSystem.get(id);
+				if (!info) {
+					timer && clearInterval(timer);
+					sseOpen && res.write("data: 任务不存在，无法获取任务详情 \n\n");
+					return res.end("data: end\n\n");
+				}
+				/** 如果状态发生变化 则说明任务已结束 */
+				if (info.status !== task.status) {
+					info.logs.split("\n").forEach((log) => res.write(`data: ${log} \n\n`));
+					timer && clearInterval(timer);
+					return res.end("data: end\n\n");
+				}
+				sseOpen && res.write("data: 任务执行中，请耐心等待... \n\n");
+			} catch (error) {
+				logger.error(new Error("sse获取日志失败", { cause: error }));
+				timer && clearInterval(timer);
+				sseOpen && res.write("data: 获取日志失败 \n\n");
+				return res.end("data: end\n\n");
+			}
+		}, 1e3);
+	} catch (error) {
+		logger.error(new Error("sse获取日志失败", { cause: error }));
+		createServerErrorResponse(res, error instanceof Error ? error.message : String(error));
+	}
+};
+/**
+* 删除任务记录
+*/
+const taskDeleteRouter = async (req, res) => {
+	const { id } = req.params;
+	if (!id || typeof id !== "string" || id.length === 0) return createServerErrorResponse(res, "任务ID不能为空");
+	try {
+		await taskSystem.delete(id);
+		createSuccessResponse(res, "任务记录删除成功");
+	} catch (error) {
+		createServerErrorResponse(res, error instanceof Error ? error.message : String(error));
+	}
+};
+
+//#endregion
+//#region src/utils/npm/npmrc.ts
+/**
+* 获取 .npmrc 文件路径
+* @param type - 类型 global 全局 project 项目
+* @param isCheck - 是否校验文件存在 不存在返回null
+*/
+const getNpmrcPath = async (type, isCheck) => {
+	let dir = "";
+	if (type === "global") {
+		const { stdout } = await exec$3("npm config get userconfig");
+		dir = stdout.trim();
+	} else dir = join(process.cwd(), ".npmrc");
+	if (isCheck && !existsSync(dir)) return null;
+	return dir;
+};
+/**
+* 获取 pnpm 配置文件的路径
+* @param isCheck - 是否校验文件存在 不存在返回null
+* - docs: {@link https://pnpm.io/zh/cli/config}
+*/
+const getPnpmConfigPath = (isCheck) => {
+	let dir = "";
+	if (process.env.XDG_CONFIG_HOME) dir = join(process.env.XDG_CONFIG_HOME, "pnpm", "rc");
+	const homeDir = homedir();
+	const platform = process.platform;
+	if (platform === "win32") dir = join(homeDir, "AppData", "Local", "pnpm", "config", "rc");
+	else if (platform === "darwin") dir = join(homeDir, "Library", "preferences", "pnpm", "rc");
+	else dir = join(homeDir, ".config", "pnpm", "rc");
+	if (isCheck && !existsSync(dir)) return null;
+	return dir;
+};
+/**
+* 获取npm、pnpm配置文件列表
+*/
+const getNpmConfigList = async () => {
+	const list = [];
+	const npmrc = await getNpmrcPath("global", true);
+	const npmrcProject = await getNpmrcPath("project", true);
+	const pnpmrc = getPnpmConfigPath(true);
+	if (npmrc) list.push({
+		path: npmrc,
+		type: "global",
+		description: "npm全局配置"
+	});
+	if (pnpmrc) list.push({
+		path: pnpmrc,
+		type: "pnpm",
+		description: "pnpm全局配置"
+	});
+	if (npmrcProject) list.push({
+		path: npmrcProject,
+		type: "project",
+		description: "当前项目配置"
+	});
+	return list;
+};
+/**
+* 传入key获取对应的npm配置
+* @param keys - 配置key
+* @returns 配置key和对应的配置值
+*/
+const getNpmConfig = async (keys) => {
+	if (typeof keys === "string") {
+		const { stdout } = await exec$3(`npm config get ${keys}`, { env: {} });
+		return stdout.trim();
+	}
+	const listResult = [];
+	for (const key of keys) {
+		const { stdout: value } = await exec$3(`npm config get ${key}`);
+		listResult.push({
+			key,
+			value: value.trim()
+		});
+	}
+	return listResult;
+};
+/**
+* 设置npmrc文件的配置
+* @param key - 配置项
+* @param value - 配置值
+*/
+const setNpmConfig = async (key, value) => {
+	await exec$3(`npm config set "${key}" "${value}"`);
+};
+
+//#endregion
+//#region src/server/dependencies/config.ts
+/**
+* 获取.npmrc文件列表
+*/
+const getNpmrcListRouter = async (_, res) => {
+	try {
+		return createSuccessResponse(res, await getNpmConfigList());
+	} catch (error) {
+		logger.error("[getNpmrcListRouter]", error);
+		return createServerErrorResponse(res, error instanceof Error ? error.message : String(error));
+	}
+};
+/**
+* 获取npm config文件内容
+*/
+const getNpmrcContentRouter = async (req, res) => {
+	try {
+		const { path } = req.body;
+		if (!(await getNpmConfigList()).find((item) => item.path === path)) return createBadRequestResponse(res, "文件不存在");
+		return createSuccessResponse(res, ini.read(path));
+	} catch (error) {
+		logger.error("[getNpmrcContentRouter]", error);
+		return createServerErrorResponse(res, error instanceof Error ? error.message : String(error));
+	}
+};
+/**
+* 获取registry、proxy、https-proxy配置
+*/
+const getNpmBaseConfigRouter = async (_, res) => {
+	try {
+		const [registry, proxy, httpsProxy] = await Promise.all([
+			getNpmConfig("registry"),
+			getNpmConfig("proxy"),
+			getNpmConfig("https-proxy")
+		]);
+		return createSuccessResponse(res, {
+			registry,
+			proxy,
+			"https-proxy": httpsProxy
+		});
+	} catch (error) {
+		logger.error("[getNpmConfigRouter]", error);
+		return createServerErrorResponse(res, error instanceof Error ? error.message : String(error));
+	}
+};
+/**
+* 保存npmrc文件
+*/
+const saveNpmrcRouter = async (req, res) => {
+	try {
+		const { path, content, baseConfig } = req.body;
+		const list = await getNpmConfigList();
+		const promises = [];
+		if (baseConfig.registry) promises.push(setNpmConfig("registry", baseConfig.registry));
+		if (baseConfig.proxy) promises.push(setNpmConfig("proxy", baseConfig.proxy));
+		if (baseConfig["https-proxy"]) promises.push(setNpmConfig("https-proxy", baseConfig["https-proxy"]));
+		await Promise.all(promises);
+		if (path && content) {
+			if (!list.find((item) => item.path === path)) return createBadRequestResponse(res, "文件不存在");
+			ini.write(content, path);
+		}
+		return createSuccessResponse(res, "保存成功");
+	} catch (error) {
+		logger.error("[saveNpmrcRouter]", error);
+		return createServerErrorResponse(res, error instanceof Error ? error.message : String(error));
+	}
+};
+
+//#endregion
+//#region src/server/plugins/config/webConfig.ts
+/**
+* 传入插件名称 获取插件的web配置
+* @param name 插件名称
+*/
+const getWebConfig = async (name) => {
+	const plugin = (await getPlugins("all", true)).find((v) => v.name === name);
+	if (!plugin) return defaultWebConfig();
+	if (plugin.type === "npm" || plugin.type === "git") {
+		const filepath = getWebConfigPath(plugin);
+		if (!filepath) return defaultWebConfig();
+		return getWebConfigMore(filepath);
+	}
+	return defaultWebConfig();
+};
+/**
+* 默认web.config参数
+*/
+const defaultWebConfig = (exists, path, customComponent, defaultComponent, page, icon) => {
+	return {
+		exists: exists ?? false,
+		path: path || "",
+		customComponent: customComponent ?? false,
+		defaultComponent: defaultComponent ?? false,
+		page: page ?? false,
+		icon: icon || {
+			color: "",
+			name: "star",
+			size: 16
+		}
+	};
+};
+/**
+* 获取web.config文件绝对路径
+*/
+const getWebConfigPath = (plugin) => {
+	const dev = isDev();
+	const pkg = plugin.pkgData;
+	if (!pkg.karin?.web) return null;
+	if (dev) {
+		if (!pkg.karin["ts-web"]) return null;
+		const filepath = path$1.join(plugin.dir, pkg.karin["ts-web"]);
+		if (!fs$1.existsSync(filepath)) return null;
+		return filepath;
+	}
+	const filepath = path$1.join(plugin.dir, pkg.karin.web);
+	if (!fs$1.existsSync(filepath)) return null;
+	return filepath;
+};
+/**
+* 存在web.config文件 获取更多信息
+* @param filepath web.config文件绝对路径
+*/
+const getWebConfigMore = async (filepath) => {
+	try {
+		const web = await imports(filepath, {
+			isImportDefault: true,
+			isRefresh: isDev()
+		});
+		return defaultWebConfig(true, filepath, typeof web?.customComponent === "function", typeof web?.components === "function", typeof web?.page === "function" || typeof web?.page?.url === "string", web?.info?.icon || web?.icon);
+	} catch (error) {
+		logger.error(new Error("获取插件web.config文件失败", { cause: error }));
+		return defaultWebConfig();
+	}
+};
+
+//#endregion
+//#region src/server/plugins/detail/list.ts
+const git = async (plugin) => {
+	try {
+		/** 本地最新提交哈希 */
+		const version = await getLocalCommitHash(plugin.dir, { short: true });
+		/** 远程最新提交哈希 */
+		const latestHash = await getRemoteCommitHash(plugin.dir, { short: true });
+		return {
+			type: "git",
+			id: plugin.pkgData.name,
+			name: plugin.name,
+			version,
+			latestVersion: latestHash,
+			webConfig: await getWebConfig(plugin.name)
+		};
+	} catch (error) {
+		logger.debug(`获取插件${plugin.name}提交哈希失败`, { cache: error });
+		return {
+			type: "git",
+			id: plugin.pkgData.name,
+			name: plugin.name,
+			version: "0.0.0",
+			latestVersion: "0.0.0",
+			webConfig: await getWebConfig(plugin.name)
+		};
+	}
+};
+const npm = async (plugin) => {
+	return {
+		type: "npm",
+		id: plugin.pkgData.name,
+		name: plugin.name,
+		version: plugin.pkgData.version,
+		latestVersion: await getNpmLatestVersion(plugin.pkgData.name) || "0.0.0",
+		webConfig: defaultWebConfig()
+	};
+};
+const app$1 = async (plugin) => {
+	return plugin.apps.map((v) => {
+		return {
+			type: "app",
+			id: plugin.name,
+			name: `${plugin.name}/${path.basename(v)}`,
+			version: "",
+			latestVersion: "",
+			webConfig: defaultWebConfig()
+		};
+	});
+};
+/**
+* 获取插件本地列表`(包含web.config相关配置)`
+* @param isRefresh 是否强制刷新
+* @returns 插件列表
+*/
+const getPluginLocalList = async (isRefresh = false) => {
+	if (!isRefresh) {
+		const cachedData = await redis$1.get(REDIS_LOCAL_PLUGIN_LIST_CACHE_KEY);
+		if (cachedData) return JSON.parse(cachedData);
+	}
+	const list = [];
+	const plugin = await getPlugins("all", true);
+	await Promise.all(plugin.map(async (plugin) => {
+		if (plugin.type === "git") return list.push(await git(plugin));
+		if (plugin.type === "npm") return list.push(await npm(plugin));
+		if (plugin.type === "app") {
+			const result = await app$1(plugin);
+			return list.push(...result);
+		}
+	}));
+	/** 更新Redis缓存，设置过期时间 */
+	await redis$1.set(REDIS_LOCAL_PLUGIN_LIST_CACHE_KEY, JSON.stringify(list), { EX: REDIS_PLUGIN_LIST_CACHE_EXPIRE });
+	return list;
+};
+/**
+* @webui 插件管理 获取插件列表Api
+*/
+const getPluginListPluginAdmin = async (req, res) => {
+	try {
+		const { isRefresh = false } = req.body;
+		createSuccessResponse(res, await getPluginLocalList(isRefresh));
+	} catch (error) {
+		createServerErrorResponse(res, error.message);
+		logger.error(error);
+	}
+};
+/**
+* @webui 获取已加载命令插件缓存信息列表
+*/
+const getLoadedCommandPluginCacheList = async (_, res) => {
+	try {
+		const list = [];
+		/**
+		* @example
+		* ```ts
+		* {
+		*  'karin-plugin-example': {
+		*    'index.ts': ['fnc'],
+		*  }
+		* }
+		* ```
+		*/
+		const map = {};
+		cache.command.forEach((plugin) => {
+			const { name: key } = plugin.pkg;
+			if (!map[key]) map[key] = {};
+			if (!map[key][plugin.file.basename]) map[key][plugin.file.basename] = [];
+			map[key][plugin.file.basename].push({
+				pluginName: plugin.file.name,
+				method: plugin.file.method
+			});
+		});
+		Object.keys(map).forEach((key) => {
+			const files = [];
+			Object.keys(map[key]).forEach((file) => {
+				files.push({
+					fileName: file,
+					command: map[key][file]
+				});
+			});
+			list.push({
+				name: key,
+				files
+			});
+		});
+		createSuccessResponse(res, list);
+	} catch (error) {
+		createServerErrorResponse(res, error.message);
+		logger.error(error);
+	}
+};
+/**
+* @webui
+* 获取前端已安装插件简约列表
+*/
+const getFrontendInstalledPluginList = async (req, res) => {
+	const isRefresh = req.body.isRefresh || false;
+	try {
+		if (!isRefresh) {
+			const cachedData = await redis$1.get(REDIS_LOCAL_PLUGIN_LIST_CACHE_KEY_FRONTEND);
+			if (cachedData) return createSuccessResponse(res, JSON.parse(cachedData));
+		}
+		/** 复用同一个获取逻辑 */
+		const [list, marketResult] = await Promise.all([getPlugins("all", false, isRefresh), getPluginMarket(isRefresh)]);
+		const marketMap = {};
+		marketResult.plugins.forEach((item) => {
+			marketMap[item.name] = item;
+		});
+		const result = await Promise.all(list.map(async (item) => {
+			const [type, name] = item.split(":");
+			/** 是否在插件市场 */
+			const market = marketMap[name];
+			const webConfig = await getWebConfig(name);
+			return {
+				id: name,
+				name,
+				type,
+				isMarketPlugin: !!market,
+				description: market?.description || "",
+				author: {
+					name: market?.author[0].name || "",
+					home: market?.author[0].home || "",
+					avatar: market?.author[0].avatar || market?.author[0].home ? `${market?.author[0].home}.png` : ""
+				},
+				repoUrl: market?.repo[0].url || "",
+				hasConfig: webConfig.defaultComponent || webConfig.page,
+				hasCustomComponent: webConfig.customComponent,
+				icon: webConfig?.icon
+			};
+		}));
+		createSuccessResponse(res, result);
+		/** 更新Redis缓存，设置过期时间 */
+		await redis$1.set(REDIS_LOCAL_PLUGIN_LIST_CACHE_KEY_FRONTEND, JSON.stringify(result), { EX: REDIS_LOCAL_PLUGIN_LIST_CACHE_EXPIRE_FRONTEND });
+	} catch (error) {
+		createServerErrorResponse(res, error.message);
+		logger.error(error);
+	}
+};
+
+//#endregion
+//#region src/server/plugins/market/index.ts
+/**
+* @webui 插件市场 获取插件列表
+*/
+const getPluginMarketList = async (req, res) => {
+	try {
+		const list = [];
+		const isForce = Boolean(req.body.refresh ?? false);
+		if (!isForce) {
+			const cache = await getCache();
+			if (cache) return createSuccessResponse(res, JSON.parse(cache));
+		}
+		const [local, { plugins: market }] = await Promise.all([getPlugins("all", true), getPluginMarket(isForce)]);
+		const registry = await getFastRegistry();
+		handleLocalPlugins(list, local, market);
+		await handleMarketPlugins(list, local, market, registry);
+		setCache(list);
+		return createSuccessResponse(res, list);
+	} catch (error) {
+		logger.error(error);
+		return createServerErrorResponse(res, error.message);
+	}
+};
+/**
+* 获取缓存
+*/
+const getCache = async () => {
+	const { redis } = await import("./redis-aLJ7wbJH.mjs").then((n) => n.r);
+	return await redis.get(REDIS_PLUGIN_MARKET_LIST_CACHE_KEY);
+};
+/**
+* 设置缓存
+*/
+const setCache = async (data) => {
+	const { redis } = await import("./redis-aLJ7wbJH.mjs").then((n) => n.r);
+	await redis.set(REDIS_PLUGIN_MARKET_LIST_CACHE_KEY, JSON.stringify(data), { EX: REDIS_PLUGIN_MARKET_LIST_CACHE_EXPIRE });
+};
+/**
+* 已安装但未在插件市场中的插件
+* @param list 插件市场列表
+* @param local 已安装插件列表
+* @param market 插件市场列表
+*/
+const handleLocalPlugins = (list, local, market) => {
+	const localPlugins = local.filter((plugin) => !market.some((m) => m.name === plugin.name));
+	for (const plugin of localPlugins) {
+		const author = getAuthorInfo();
+		const local = {
+			name: plugin.name,
+			installed: true,
+			type: plugin.type,
+			version: "",
+			description: "",
+			home: ""
+		};
+		if (plugin.type !== "app") {
+			const pkg = plugin.pkgData;
+			local.version = pkg.version;
+			local.description = pkg.description;
+			local.home = pkg.homepage || pkg?.repository?.url;
+			if (local.home) {
+				const url = new URL(local.home);
+				const [owner] = url.pathname.split("/").filter(Boolean);
+				author.name = pkg.author || owner;
+				author.home = `${url.origin}/${owner}`;
+				if (url.hostname.includes("github") || url.hostname.includes("gitee")) author.avatar = `${url.origin}/${owner}.png`;
+			}
+		}
+		list.push({
+			type: "local",
+			local,
+			author
+		});
+	}
+};
+/**
+* 处理插件市场的插件
+* @param list 插件市场列表
+* @param local 已安装插件列表
+* @param market 插件市场列表
+* @param registry 注册源
+*/
+const handleMarketPlugins = async (list, local, market, registry) => {
+	await Promise.all(market.map(async (plugin) => {
+		const data = {
+			installed: false,
+			type: plugin.type,
+			version: "",
+			name: plugin.name,
+			description: plugin.description,
+			home: plugin.home
+		};
+		/** 检查是否已经安装 返回安装的插件 */
+		const pkg = local.find((p) => p.name === plugin.name);
+		if (pkg) {
+			data.installed = true;
+			data.type = pkg.type;
+			data.version = pkg.pkgData.version;
+		} else data.version = await handlePluginVersion(plugin, registry);
+		const author = getAuthorInfo();
+		if (plugin.author?.length) {
+			author.name = plugin.author[0].name;
+			author.home = plugin.author[0].home;
+			author.avatar = plugin.author[0].avatar || `${plugin.author[0].home}.png`;
+		}
+		list.push({
+			type: "market",
+			market: plugin,
+			local: data,
+			author
+		});
+	}));
+};
+/**
+* 获取默认作者信息
+*/
+const getAuthorInfo = () => {
+	/** 嘿嘿嘿，三月七天下第一可爱^_^ */
+	return {
+		name: "神秘的三月七",
+		home: "",
+		avatar: "https://bbs-static.miyoushe.com/static/2025/03/05/fed22237b02cf398ef993b98b83989b3_7330898026089067872.png"
+	};
+};
+/**
+* 处理插件的版本
+* @param plugin 插件
+* @param registry 注册源
+* @returns 返回插件的版本
+*/
+const handlePluginVersion = async (plugin, registry) => {
+	if (plugin.type === "npm") {
+		const result = await axios.get(`${registry}/${plugin.name}/latest`);
+		if (result) return result.data.version;
+	} else {
+		const github = plugin.repo.find((r) => r.type === "github");
+		if (github) {
+			const [owner, repo] = new URL(github.url).pathname.split("/").filter(Boolean);
+			const { version } = await getPackageJson(owner, repo);
+			return version;
+		}
+		return "0.0.0";
+	}
+};
+
+//#endregion
+//#region src/server/router/index.ts
+/**
+* karin内部路由
+*/
+const router = Router();
+/** 日志 */
+router.use(logMiddleware);
+/** 鉴权 */
+router.use(authMiddleware);
+/** 解析json */
+router.use(express.json());
+/** 登录 */
+router.post(LOGIN_ROUTER, loginRouter);
+/** 刷新令牌 */
+router.post(REFRESH_ROUTER, refreshRouter);
+/** 获取系统配置 */
+router.post(GET_CONFIG_ROUTER, getConfig);
+/** 保存系统配置 */
+router.post(SAVE_CONFIG_ROUTER, saveConfig);
+/** 获取日志 */
+router.get(GET_LOG_ROUTER, getLogRouter);
+/** 设置日志等级 */
+router.get(SET_LOG_LEVEL_ROUTER, logLevelRouter);
+/** 获取日志文件列表 */
+router.get(GET_LOG_FILE_LIST_ROUTER, getLogFileListRouter);
+/** 获取指定日志文件 */
+router.get(GET_LOG_FILE_ROUTER, getLogFileRouter);
+/** 退出karin */
+router.post(EXIT_ROUTER, exitRouter);
+/** 重启karin */
+router.post(RESTART_ROUTER, restartRouter);
+/** 获取网络状态 */
+router.get(GET_NETWORK_STATUS_ROUTER, networkStatusRouter);
+/** 更新karin */
+router.get(UPDATE_CORE_ROUTER, updateCoreRouter);
+/** 获取所有bot列表 */
+router.get(GET_BOTS_ROUTER, getBotsRouter);
+/** console适配器路由 */
+router.get(CONSOLE_ROUTER, consoleRouter);
+/** 系统ws连接 */
+router.get(SYSTEM_STATUS_WS_ROUTER, infoRouter);
+/** ping路由 */
+router.get(PING_ROUTER, pingRouter);
+/** karin状态 */
+router.get(SYSTEM_STATUS_KARIN_ROUTER, statusRouter);
+/** 系统状态 */
+router.get(SYSTEM_STATUS_ROUTER, systemStatusRealTimeHandler);
+/** 检查是否安装了指定的npm包 */
+router.post(CHECK_PLUGIN_ROUTER, checkPlugin);
+/** 获取插件配置 */
+router.post(GET_PLUGIN_CONFIG_ROUTER, pluginGetConfig);
+/** 保存插件配置 */
+router.post(SAVE_PLUGIN_CONFIG_ROUTER, pluginSaveConfig);
+/** 判断插件web.config是否存在 */
+router.post(IS_PLUGIN_CONFIG_EXIST_ROUTER, pluginIsConfigExist);
+/** 插件管理 */
+router.post(PLUGIN_ADMIN_ROUTER, pluginAdminRouter);
+/** 安装插件 */
+router.post(INSTALL_PLUGIN_ROUTER, pluginInstall);
+/** 卸载插件 */
+router.post(UNINSTALL_PLUGIN_ROUTER, pluginUninstall);
+/** 获取任务状态 */
+router.post(GET_TASK_STATUS_ROUTER, pluginGetTaskStatus);
+/** 获取任务列表 */
+router.post(GET_TASK_LIST_ROUTER, pluginGetTaskList);
+/** 更新任务状态 */
+router.post(UPDATE_TASK_STATUS_ROUTER, pluginUpdateTaskStatus);
+/** 获取已安装插件详情 */
+router.post(GET_LOCAL_PLUGIN_LIST_ROUTER, pluginGetLocalList);
+/** @version 1.8.0 获取已安装插件名称列表 */
+router.post(GET_PLUGIN_LIST_PLUGIN_ADMIN_ROUTER, getPluginListPluginAdmin);
+/** 创建终端 */
+router.post(CREATE_TERMINAL_ROUTER, createTerminalHandler);
+/** 获取终端列表 */
+router.get(GET_TERMINAL_LIST_ROUTER, getTerminalListHandler);
+/** 关闭终端 */
+router.post(CLOSE_TERMINAL_ROUTER, closeTerminalHandler);
+/** 获取webui插件列表 */
+router.get(GET_WEBUI_PLUGIN_LIST_ROUTER, getWebuiPluginList);
+/** 安装webui插件 */
+router.post(INSTALL_WEBUI_PLUGIN_ROUTER, installWebui);
+/** 卸载webui插件 */
+router.post(UNINSTALL_WEBUI_PLUGIN_ROUTER, uninstallWebui);
+/** 获取webui插件版本 */
+router.post(GET_WEBUI_PLUGIN_VERSIONS_ROUTER, getWebuiPluginVersions);
+/** 更新webui插件到指定版本 */
+router.post(UPDATE_WEBUI_PLUGIN_VERSION_ROUTER, updateWebuiPluginVersion);
+/** 获取依赖列表 */
+router.post(GET_DEPENDENCIES_LIST_ROUTER, getDependenciesListRouter);
+/** 依赖管理（安装/删除） */
+router.post(MANAGE_DEPENDENCIES_ROUTER, manageDependenciesRouter);
+/** 获取.npmrc文件列表 */
+router.post(GET_NPMRC_LIST_ROUTER, getNpmrcListRouter);
+/** 获取npm config文件内容 */
+router.post(GET_NPM_CONFIG_ROUTER, getNpmrcContentRouter);
+/** 获取npm registry、proxy、https-proxy配置 */
+router.post(GET_NPM_BASE_CONFIG_ROUTER, getNpmBaseConfigRouter);
+/** 保存npmrc文件 */
+router.post(SAVE_NPMRC_ROUTER, saveNpmrcRouter);
+/** 获取任务列表 */
+router.post(TASK_LIST_ROUTER, taskListRouter);
+/** 执行任务 */
+router.get(TASK_RUN_ROUTER, taskRunRouter);
+/** 获取任务日志 */
+router.post(TASK_LOGS_ROUTER, taskLogsRouter);
+/** 删除任务记录 */
+router.post(TASK_DELETE_ROUTER, taskDeleteRouter);
+/** @version 1.8.0 获取已加载命令插件缓存信息列表 */
+router.post(GET_LOADED_COMMAND_PLUGIN_CACHE_LIST_ROUTER, getLoadedCommandPluginCacheList);
+/** @version 1.8.0 获取插件市场列表 */
+router.post(GET_PLUGIN_MARKET_LIST_ROUTER, getPluginMarketList);
+/** @version 1.8.0 获取本地插件列表 用于插件索引页面渲染简约列表 */
+router.post(GET_LOCAL_PLUGIN_FRONTEND_LIST_ROUTER, getFrontendInstalledPluginList);
+
+//#endregion
+//#region src/server/system/root.ts
+/**
+* 根路由
+*/
+const rootRouter = async (_req, res) => {
+	createSuccessResponse(res, null, "雪霁银妆素，桔高映琼枝。");
+};
+
+//#endregion
+//#region src/server/app/app.ts
+var app_exports = /* @__PURE__ */ __exportAll({
+	app: () => app,
+	initExpress: () => initExpress,
+	server: () => server
+});
+/**
+* @public
+* @description express 服务
+*/
+const app = express();
+/**
+* @public
+* @description http 服务
+*/
+const server = createServer(app);
+/**
+* 监听端口
+* @param port 监听端口
+* @param host 监听地址
+*/
+const listen = (port, host) => {
+	server.listen(port, host, () => {
+		logger.info(`[server] express 正在监听: http://${host}:${port}`);
+	});
+	listeners.once(ONLINE, () => {
+		logger.info("\n--------------------^_^--------------------");
+		logger.info(`[server] ${logger.yellow("WebUI 访问地址:")} ${logger.green(`http://127.0.0.1:${port}/web/login?token=${process.env.HTTP_AUTH_KEY}`)}`);
+		logger.info(`[server] HTTP  鉴权秘钥: ${logger.green(process.env.HTTP_AUTH_KEY)}`);
+		logger.info(`[server] WS    鉴权秘钥: ${logger.green(process.env.WS_SERVER_AUTH_KEY) || logger.yellow("没有设置鉴权秘钥")}`);
+		logger.info("-------------------------------------------");
+		logger.info(`[OneBot] ${logger.yellow("协议端连接地址:")} ${logger.green(`ws://127.0.0.1:${process.env.HTTP_PORT}`)}`);
+		logger.info(`[puppet] 渲染器连接地址: ${logger.green(`ws://127.0.0.1:${process.env.HTTP_PORT}/puppeteer`)}`);
+		logger.info("\n-------------------------------------------");
+	});
+};
+/**
+* web 服务
+*/
+const web = (dir) => {
+	/** web静态文件目录 */
+	const webDir = path.join(dir.karinDir, "dist/web");
+	/** 静态文件 */
+	app.use("/web", express.static(webDir));
+	/** 沙盒数据 一般存储用户头像 */
+	app.use("/sandbox/data", express.static(dir.sandboxDataPath));
+	/** 沙盒临时文件 一般存储临时文件 */
+	app.use("/sandbox/file", express.static(dir.sandboxTempPath));
+	/** 处理 /web 路径下的所有请求，确保 SPA 路由可以正常工作 */
+	app.get("/web/{*splat}", (_, res) => {
+		res.sendFile("index.html", { root: path.resolve(webDir) });
+	});
+	/**
+	* 不注册全局兜底重定向。
+	* 插件可能会在启动后挂载自己的 Web 路由，例如 /my-plugin。
+	* 如果这里把所有未命中的路径重定向到 /web，会导致插件 WebUI 被 Karin WebUI 吞掉。
+	*/
+};
+/**
+* @internal
+* @description 初始化express
+* @param dir root
+* @param port 监听端口
+* @param host 监听地址
+*/
+const initExpress = async (dir, port, host) => {
+	await import("./ws-BLDoC2gV.mjs");
+	app.use(BASE_ROUTER, router);
+	app.get("/", rootRouter);
+	web(dir);
+	listen(port, host);
+};
+
+//#endregion
+export { getLocalCommitHash as _, authMiddleware as a, ONLINE as b, pkgLoadModule as c, createFile$1 as d, createLogger as f, getLocalBranches as g, getDefaultBranch as h, router as i, pkgLoads as l, gitPull as m, app_exports as n, findPkgByFile as o, createPkg as p, server as r, pkgCache as s, app as t, pkgSort as u, getRemoteBranches as v, getRemoteCommitHash as y };