mioku 0.9.2 → 0.9.4

package/dist/index.cjs

@@ -1,9 +1,9 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-const node_fs = require_chunk.__toESM(require("node:fs"));
-const node_path = require_chunk.__toESM(require("node:path"));
-const fs_promises = require_chunk.__toESM(require("fs/promises"));
-const path = require_chunk.__toESM(require("path"));
 const fs = require_chunk.__toESM(require("fs"));
+const path = require_chunk.__toESM(require("path"));
+const url = require_chunk.__toESM(require("url"));
+const fs_promises = require_chunk.__toESM(require("fs/promises"));
+const mioki = require_chunk.__toESM(require("mioki"));
 
 //#region src/core/logger.ts
 const fallbackLogger = {
@@ -26,9 +26,8 @@ const logger = {
 };
 
 //#endregion
-//#region src/core/plugin-linker.ts
-const DEFAULT_RUNTIME_PLUGINS_DIR = ".mioku/plugins";
-async function pathExists$3(filePath) {
+//#region src/core/module-scanner.ts
+async function pathExists(filePath) {
 	try {
 		await fs_promises.access(filePath);
 		return true;
@@ -36,6 +35,66 @@ async function pathExists$3(filePath) {
 		return false;
 	}
 }
+async function resolveRealpath(p) {
+	try {
+		return await fs_promises.realpath(p);
+	} catch {
+		return p;
+	}
+}
+function toImportPath(filePath) {
+	if (process.platform === "win32") return "file:///" + filePath.replace(/\\/g, "/");
+	return filePath;
+}
+async function scanLocalDir(dir) {
+	const results = [];
+	if (!await pathExists(dir)) return results;
+	let entries;
+	try {
+		entries = await fs_promises.readdir(dir, { withFileTypes: true });
+	} catch {
+		return results;
+	}
+	for (const entry of entries) {
+		const entryPath = path.join(dir, entry.name);
+		try {
+			const stat = await fs_promises.stat(entryPath);
+			if (!stat.isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		results.push({
+			name: entry.name,
+			path: await resolveRealpath(entryPath)
+		});
+	}
+	return results;
+}
+async function scanNodeModules(prefix) {
+	const results = [];
+	const nodeModulesPath = path.resolve(process.cwd(), "node_modules");
+	if (!await pathExists(nodeModulesPath)) return results;
+	let entries;
+	try {
+		entries = await fs_promises.readdir(nodeModulesPath, { withFileTypes: true });
+	} catch {
+		return results;
+	}
+	for (const entry of entries) {
+		if (!entry.name.startsWith(prefix)) continue;
+		const name = entry.name.slice(prefix.length);
+		const fullPath = path.join(nodeModulesPath, entry.name);
+		results.push({
+			name,
+			path: await resolveRealpath(fullPath)
+		});
+	}
+	return results;
+}
+
+//#endregion
+//#region src/core/plugin-linker.ts
+const DEFAULT_RUNTIME_PLUGINS_DIR = ".mioku/plugins";
 async function removeIfBrokenSymlink(entryPath) {
 	let stat;
 	try {
@@ -54,8 +113,7 @@ async function removeIfBrokenSymlink(entryPath) {
 	}
 }
 function relativeSymlinkTarget(linkPath, targetPath) {
-	const relativePath = path.relative(path.dirname(linkPath), targetPath);
-	return relativePath || ".";
+	return path.relative(path.dirname(linkPath), targetPath) || ".";
 }
 async function ensurePluginLink(runtimePluginsDir, metadata) {
 	const linkPath = path.join(runtimePluginsDir, metadata.name);
@@ -80,7 +138,7 @@ async function ensurePluginLink(runtimePluginsDir, metadata) {
 		logger.warn(`[plugin-linker] ${linkPath} exists and is not a symlink, skip linking ${metadata.name}`);
 		return false;
 	}
-	if (!await pathExists$3(targetPath)) {
+	if (!await pathExists(targetPath)) {
 		logger.warn(`[plugin-linker] Plugin target missing, skip linking ${metadata.name}: ${targetPath}`);
 		return false;
 	}
@@ -90,12 +148,11 @@ async function ensurePluginLink(runtimePluginsDir, metadata) {
 }
 async function prepareRuntimePluginLinks(plugins, runtimePluginsDir = path.resolve(process.cwd(), DEFAULT_RUNTIME_PLUGINS_DIR)) {
 	await fs_promises.mkdir(runtimePluginsDir, { recursive: true });
-	const discoveredNames = new Set(plugins.map((plugin) => plugin.name));
+	const discoveredNames = new Set(plugins.map((p) => p.name));
 	const entries = await fs_promises.readdir(runtimePluginsDir, { withFileTypes: true });
 	for (const entry of entries) {
 		const entryPath = path.join(runtimePluginsDir, entry.name);
-		const symlinkState = await removeIfBrokenSymlink(entryPath);
-		if (symlinkState !== "ok") continue;
+		if (await removeIfBrokenSymlink(entryPath) !== "ok") continue;
 		if (entry.isSymbolicLink() && !discoveredNames.has(entry.name)) {
 			await fs_promises.rm(entryPath, { force: true });
 			logger.info(`[plugin-linker] Removed stale plugin link: ${entry.name}`);
@@ -107,279 +164,166 @@ async function prepareRuntimePluginLinks(plugins, runtimePluginsDir = path.resol
 }
 
 //#endregion
-//#region src/core/plugin-manager.ts
-const PLUGIN_MANAGER_SYMBOL = Symbol.for("mioku.plugin-manager");
-async function pathExists$2(filePath) {
-	try {
-		await fs_promises.access(filePath);
-		return true;
-	} catch {
-		return false;
-	}
+//#region src/core/registry.ts
+const STORE_SYMBOL = Symbol.for("mioku.globalStore");
+function store$1() {
+	const g = globalThis;
+	if (!g[STORE_SYMBOL]) g[STORE_SYMBOL] = {};
+	return g[STORE_SYMBOL];
+}
+function getOrCreate(key, factory) {
+	const s = store$1();
+	if (s[key] === void 0) s[key] = factory();
+	return s[key];
 }
-/**
-* 插件管理器
-*
-* Discover and manage plugins from both local directories and node_modules.
-*/
+
+//#endregion
+//#region src/core/plugin-manager.ts
+const PLUGIN_PREFIX = "mioku-plugin-";
 var PluginManager = class PluginManager {
-	pluginMetadata = new Map();
+	plugins = new Map();
 	static getInstance() {
-		const g = global;
-		if (!g[PLUGIN_MANAGER_SYMBOL]) g[PLUGIN_MANAGER_SYMBOL] = new PluginManager();
-		return g[PLUGIN_MANAGER_SYMBOL];
+		return getOrCreate("plugin-manager", () => new PluginManager());
 	}
 	async discoverPlugins(miokuConfig = {}) {
-		const configuredPluginsDir = miokuConfig.plugins_dir;
-		const pluginsDir = configuredPluginsDir && configuredPluginsDir !== DEFAULT_RUNTIME_PLUGINS_DIR ? path.resolve(process.cwd(), configuredPluginsDir) : path.resolve(process.cwd(), "plugins");
-		this.pluginMetadata.clear();
-		if (!await pathExists$2(pluginsDir)) (0, fs.mkdirSync)(pluginsDir, { recursive: true });
-		const discovered = [];
-		if (await pathExists$2(pluginsDir)) {
-			const localPlugins = await this.discoverFromDir(pluginsDir);
-			discovered.push(...localPlugins);
-		}
-		const nodeModulesPlugins = await this.discoverFromNodeModules();
-		discovered.push(...nodeModulesPlugins);
-		logger.info(`O.o 发现了 ${this.pluginMetadata.size} 个插件`);
-		return Array.from(this.pluginMetadata.values());
-	}
-	async discoverFromDir(pluginsDir) {
-		const discovered = [];
-		try {
-			const entries = await fs_promises.readdir(pluginsDir, { withFileTypes: true });
-			for (const entry of entries) {
-				const pluginPath = path.join(pluginsDir, entry.name);
-				const metadataPath = await this.resolveDirectoryPath(pluginPath);
-				if (!metadataPath) continue;
-				const metadata = await this.loadPluginMetadata(entry.name, pluginPath);
-				if (metadata) {
-					discovered.push(metadata);
-					this.pluginMetadata.set(metadata.name, metadata);
-				}
-			}
-		} catch (error) {
-			logger.error(`扫描插件目录失败: ${error}`);
+		const configuredDir = miokuConfig.plugins_dir;
+		const pluginsDir = configuredDir && configuredDir !== DEFAULT_RUNTIME_PLUGINS_DIR ? path.resolve(process.cwd(), configuredDir) : path.resolve(process.cwd(), "plugins");
+		this.plugins.clear();
+		if (!await pathExists(pluginsDir)) (0, fs.mkdirSync)(pluginsDir, { recursive: true });
+		const local = await scanLocalDir(pluginsDir);
+		for (const { name, path: p } of local) {
+			const metadata = await this.loadPluginMetadata(name, p);
+			if (metadata) this.plugins.set(metadata.name, metadata);
 		}
-		return discovered;
-	}
-	async discoverFromNodeModules() {
-		const discovered = [];
-		const nodeModulesPath = path.resolve(process.cwd(), "node_modules");
-		if (!await pathExists$2(nodeModulesPath)) return discovered;
-		try {
-			const entries = await fs_promises.readdir(nodeModulesPath, { withFileTypes: true });
-			for (const entry of entries) {
-				if (!entry.name.startsWith("mioku-plugin-")) continue;
-				const pluginName = entry.name.replace(/^mioku-plugin-/, "");
-				const pluginPath = path.join(nodeModulesPath, entry.name);
-				const metadata = await this.loadPluginMetadata(pluginName, pluginPath);
-				if (metadata) {
-					discovered.push(metadata);
-					this.pluginMetadata.set(metadata.name, metadata);
-				}
-			}
-		} catch (error) {
-			logger.debug(`扫描 node_modules 插件失败: ${error}`);
-		}
-		return discovered;
-	}
-	async resolveDirectoryPath(entryPath) {
-		try {
-			const stat = await fs_promises.stat(entryPath);
-			return stat.isDirectory() ? entryPath : null;
-		} catch {
-			return null;
+		const external = await scanNodeModules(PLUGIN_PREFIX);
+		for (const { name, path: p } of external) {
+			const metadata = await this.loadPluginMetadata(name, p);
+			if (metadata) this.plugins.set(metadata.name, metadata);
 		}
+		logger.info(`O.o 发现了 ${this.plugins.size} 个插件`);
+		return [...this.plugins.values()];
 	}
 	async loadPluginMetadata(name, pluginPath) {
-		let resolvedPath = pluginPath;
-		try {
-			resolvedPath = await fs_promises.realpath(pluginPath);
-		} catch {}
-		const packageJsonPath = path.join(resolvedPath, "package.json");
+		const resolvedPath = await resolveRealpath(pluginPath);
 		let packageJson = null;
 		try {
-			const content = await fs_promises.readFile(packageJsonPath, "utf-8");
-			packageJson = JSON.parse(content);
-		} catch {}
-		const metadata = {
+			packageJson = JSON.parse(await fs_promises.readFile(path.join(resolvedPath, "package.json"), "utf-8"));
+		} catch (error) {
+			logger.warn(`[plugin-manager] 读取 ${name} 的 package.json 失败: ${error}`);
+		}
+		const config = packageJson?.mioku ?? {};
+		return {
 			name,
-			version: packageJson?.version || "0.0.0",
+			version: packageJson?.version ?? "0.0.0",
 			description: packageJson?.description,
 			path: resolvedPath,
-			packageJson,
-			config: packageJson?.mioku || {}
+			packageJson: packageJson ?? {},
+			config
 		};
-		return metadata;
 	}
 	collectRequiredServices() {
 		const services = new Set();
-		for (const metadata of this.pluginMetadata.values()) if (metadata.config.services) metadata.config.services.forEach((s) => services.add(s));
+		for (const metadata of this.plugins.values()) for (const service of metadata.config.services ?? []) services.add(service);
 		return services;
 	}
 	getPluginMetadata(name) {
-		return this.pluginMetadata.get(name);
+		return this.plugins.get(name);
 	}
 	getAllMetadata() {
-		return Array.from(this.pluginMetadata.values());
+		return [...this.plugins.values()];
 	}
 	reset() {
-		this.pluginMetadata.clear();
+		this.plugins.clear();
 	}
 };
 var plugin_manager_default = PluginManager.getInstance();
 
 //#endregion
 //#region src/core/service-manager.ts
-const SERVICE_MANAGER_SYMBOL = Symbol.for("mioku.service-manager");
-async function pathExists$1(filePath) {
-	try {
-		await fs_promises.access(filePath);
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* 服务管理器
-*/
+const SERVICE_PREFIX = "mioku-service-";
 var ServiceManager = class ServiceManager {
 	services = new Map();
 	serviceMetadata = new Map();
-	servicesDir = "services";
 	static getInstance() {
-		const g = global;
-		if (!g[SERVICE_MANAGER_SYMBOL]) g[SERVICE_MANAGER_SYMBOL] = new ServiceManager();
-		return g[SERVICE_MANAGER_SYMBOL];
+		return getOrCreate("service-manager", () => new ServiceManager());
 	}
 	async discoverServices(miokuConfig = {}) {
-		if (miokuConfig.services_dir) this.servicesDir = path.resolve(process.cwd(), miokuConfig.services_dir);
-		else this.servicesDir = path.resolve(process.cwd(), "services");
-		const discovered = [];
+		const servicesDir = miokuConfig.services_dir ? path.resolve(process.cwd(), miokuConfig.services_dir) : path.resolve(process.cwd(), "services");
 		this.serviceMetadata.clear();
-		if ((0, fs.existsSync)(this.servicesDir)) {
-			const localServices = await this.discoverFromDir(this.servicesDir);
-			discovered.push(...localServices);
-		} else (0, fs.mkdirSync)(this.servicesDir, { recursive: true });
-		await this.loadBuiltinServices();
-		logger.info(`o.O 发现了 ${this.serviceMetadata.size} 个服务`);
-		return Array.from(this.serviceMetadata.values());
-	}
-	async discoverFromDir(servicesDir) {
-		const discovered = [];
-		try {
-			const entries = await fs_promises.readdir(servicesDir, { withFileTypes: true });
-			for (const entry of entries) {
-				if (!entry.isDirectory()) continue;
-				const servicePath = path.join(servicesDir, entry.name);
-				const metadata = await this.loadServiceMetadata(entry.name, servicePath);
-				if (metadata) {
-					discovered.push(metadata);
-					this.serviceMetadata.set(entry.name, metadata);
-				}
+		if ((0, fs.existsSync)(servicesDir)) {
+			const local = await scanLocalDir(servicesDir);
+			for (const { name, path: p } of local) {
+				const metadata = await this.loadServiceMetadata(name, p);
+				if (metadata) this.serviceMetadata.set(name, metadata);
 			}
-		} catch (error) {
-			logger.error(`扫描服务目录失败: ${error}`);
+		} else (0, fs.mkdirSync)(servicesDir, { recursive: true });
+		const external = await scanNodeModules(SERVICE_PREFIX);
+		for (const { name, path: p } of external) {
+			const metadata = await this.loadServiceMetadata(name, p);
+			if (metadata) this.serviceMetadata.set(name, metadata);
 		}
-		return discovered;
+		logger.info(`o.O 发现了 ${this.serviceMetadata.size} 个服务`);
+		return [...this.serviceMetadata.values()];
 	}
 	async loadServiceMetadata(name, servicePath) {
-		let resolvedPath = servicePath;
-		try {
-			resolvedPath = await fs_promises.realpath(servicePath);
-		} catch {}
-		const packageJsonPath = path.join(resolvedPath, "package.json");
-		if (!await pathExists$1(packageJsonPath)) return null;
+		const packageJsonPath = path.join(servicePath, "package.json");
+		if (!await pathExists(packageJsonPath)) return null;
 		try {
 			const packageJson = JSON.parse(await fs_promises.readFile(packageJsonPath, "utf-8"));
-			const metadata = {
+			return {
 				name,
-				version: packageJson.version || "0.0.0",
+				version: packageJson.version ?? "0.0.0",
 				description: packageJson.description,
-				path: resolvedPath,
+				path: servicePath,
 				packageJson
 			};
-			return metadata;
 		} catch (error) {
-			logger.error(`解析服务 ${name} 失败: ${error.message}`);
+			logger.warn(`[service-manager] 解析服务 ${name} 失败: ${error}`);
 			return null;
 		}
 	}
-	/**
-	* Load built-in services from the package
-	*/
-	async loadBuiltinServices() {
-		await this.discoverFromNodeModules();
-	}
-	async discoverFromNodeModules() {
-		const nodeModulesPath = path.resolve(process.cwd(), "node_modules");
-		if (!await pathExists$1(nodeModulesPath)) return;
-		try {
-			const entries = await fs_promises.readdir(nodeModulesPath, { withFileTypes: true });
-			for (const entry of entries) {
-				if (!entry.name.startsWith("mioku-service-")) continue;
-				const serviceName = entry.name.replace(/^mioku-service-/, "");
-				const servicePath = path.join(nodeModulesPath, entry.name);
-				const metadata = await this.loadServiceMetadata(serviceName, servicePath);
-				if (metadata) this.serviceMetadata.set(serviceName, metadata);
-			}
-		} catch (error) {
-			logger.debug(`扫描 node_modules 服务失败: ${error}`);
-		}
-	}
-	async checkMissingServices(requiredServices) {
+	async checkMissingServices(required) {
 		const missing = [];
-		for (const serviceName of requiredServices) if (!this.serviceMetadata.has(serviceName)) missing.push(serviceName);
+		for (const name of required) if (!this.serviceMetadata.has(name)) missing.push(name);
 		return missing;
 	}
 	async loadAllServices(ctx) {
-		const allMetadata = Array.from(this.serviceMetadata.values());
-		logger.info(`O.o 准备加载 ${allMetadata.length} 个服务...`);
-		for (const metadata of allMetadata) await this.loadService(metadata, ctx);
+		const all = [...this.serviceMetadata.values()];
+		logger.info(`O.o 准备加载 ${all.length} 个服务...`);
+		for (const metadata of all) await this.loadService(metadata, ctx);
 	}
 	async loadService(metadata, ctx) {
 		try {
-			const indexPath = path.join(metadata.path, "index.ts");
-			const indexJsPath = path.join(metadata.path, "index.js");
-			const indexExists = await pathExists$1(indexPath);
-			const indexJsExists = await pathExists$1(indexJsPath);
-			const entryPoint = indexExists ? indexPath : indexJsPath;
-			if (!entryPoint || !indexExists && !indexJsExists) {
-				logger.error(`服务 ${metadata.name} 入口丢失`);
+			const tsEntry = path.join(metadata.path, "index.ts");
+			const jsEntry = path.join(metadata.path, "index.js");
+			const entry = await pathExists(tsEntry) ? tsEntry : await pathExists(jsEntry) ? jsEntry : null;
+			if (!entry) {
+				logger.error(`[service-manager] 服务 ${metadata.name} 入口丢失`);
 				return false;
 			}
-			let importPath = entryPoint;
-			if (process.platform === "win32") importPath = "file:///" + entryPoint.replace(/\\/g, "/");
-			const serviceModule = await import(importPath);
-			const service = serviceModule.default || serviceModule;
-			if (!service || typeof service.init !== "function") return false;
-			await service.init();
-			if (service.api) {
-				if (!ctx.services) ctx.services = {};
-				ctx.services[metadata.name] = service.api;
+			const serviceModule = await import(toImportPath(entry));
+			const service = serviceModule.default ?? serviceModule;
+			if (!service || typeof service.init !== "function") {
+				logger.warn(`[service-manager] 服务 ${metadata.name} 无效：缺少 init()`);
+				return false;
 			}
+			await service.init();
+			if (service.api) ctx.services[metadata.name] = service.api;
 			this.services.set(metadata.name, service);
 			return true;
 		} catch (error) {
-			logger.error(`加载服务 ${metadata.name} 失败: ${error.message}`);
+			logger.error(`[service-manager] 加载服务 ${metadata.name} 失败: ${error}`);
 			return false;
 		}
 	}
-	/**
-	* Register a builtin service directly
-	*/
 	registerBuiltinService(name, service) {
 		this.services.set(name, service);
 	}
-	/**
-	* Get a loaded service
-	*/
 	getService(name) {
 		return this.services.get(name);
 	}
 	async disposeAll() {
-		for (const [name, service] of this.services) if (service.dispose) await service.dispose();
+		for (const [, service] of this.services) await service.dispose?.();
 		this.services.clear();
 	}
 	reset() {
@@ -390,21 +334,56 @@ var ServiceManager = class ServiceManager {
 var service_manager_default = ServiceManager.getInstance();
 
 //#endregion
-//#region src/core/plugin-artifact-registry.ts
-async function pathExists(filePath) {
+//#region src/core/bootstrap.ts
+async function readMiokuConfig() {
+	const packageJsonPath = path.join(process.cwd(), "package.json");
 	try {
-		await fs_promises.access(filePath);
-		return true;
+		const pkg = JSON.parse(await fs_promises.readFile(packageJsonPath, "utf-8"));
+		return pkg.mioki ?? {};
 	} catch {
-		return false;
+		return {};
 	}
 }
-function toImportPath(filePath) {
-	if (process.platform === "win32") return "file:///" + filePath.replace(/\\/g, "/");
-	return filePath;
+function ensureRuntimeDirectories() {
+	for (const dir of [
+		"data",
+		"config",
+		"temp"
+	]) if (!(0, fs.existsSync)(dir)) (0, fs.mkdirSync)(dir, { recursive: true });
+}
+async function discoverAndLinkPlugins(miokuConfig) {
+	logger.info("O.o Miku 正在翻找插件..");
+	const discovered = await plugin_manager_default.discoverPlugins(miokuConfig);
+	logger.info(`O.o 共发现 ${discovered.length} 个插件: ${discovered.map((p) => p.name).join(", ")}`);
+	const runtimePluginsDir = path.resolve(process.cwd(), DEFAULT_RUNTIME_PLUGINS_DIR);
+	return prepareRuntimePluginLinks(discovered, runtimePluginsDir);
 }
+async function discoverAndValidateServices(miokuConfig) {
+	logger.info("o.O Miku 正在翻找服务..");
+	await service_manager_default.discoverServices(miokuConfig);
+	const requiredServices = plugin_manager_default.collectRequiredServices();
+	const missing = await service_manager_default.checkMissingServices(requiredServices);
+	if (missing.length > 0) logger.warn(`发现缺失服务: ${missing.join(", ")}`);
+}
+function applyPluginAllowlist(miokuConfig, botConfig$1, linkedPluginNames) {
+	botConfig$1.plugins_dir = DEFAULT_RUNTIME_PLUGINS_DIR;
+	if (miokuConfig.plugins !== void 0) return;
+	for (const name of linkedPluginNames) if (!botConfig$1.plugins.includes(name)) botConfig$1.plugins.push(name);
+}
+async function bootstrapMioku(deps) {
+	const { cwd, botConfig: botConfig$1, startMioki } = deps;
+	const miokuConfig = await readMiokuConfig();
+	ensureRuntimeDirectories();
+	const linkedPluginNames = await discoverAndLinkPlugins(miokuConfig);
+	await discoverAndValidateServices(miokuConfig);
+	applyPluginAllowlist(miokuConfig, botConfig$1, linkedPluginNames);
+	await startMioki({ cwd });
+}
+
+//#endregion
+//#region src/core/plugin-artifact-registry.ts
 function isAISkill(value) {
-	return value && typeof value === "object" && typeof value.name === "string" && Array.isArray(value.tools);
+	return !!value && typeof value === "object" && typeof value.name === "string" && Array.isArray(value.tools);
 }
 function extractSkills(moduleExports) {
 	const candidates = [
@@ -425,18 +404,19 @@ async function resolveSkillsEntry(pluginPath) {
 	if (await pathExists(jsPath)) return jsPath;
 	return null;
 }
-/**
-* Auto-register plugin help manifests and AI skills
-*/
+function hasPublicKeyword(keywords) {
+	return Array.isArray(keywords) && keywords.includes("mioku");
+}
 async function registerPluginArtifacts(ctx) {
-	const enabledPlugins = new Set(Array.isArray(ctx.botConfig?.plugins) ? ctx.botConfig.plugins : []);
+	const enabledPlugins = new Set(mioki.botConfig.plugins ?? []);
 	const pluginMetadata = plugin_manager_default.getAllMetadata().filter((metadata) => enabledPlugins.size > 0 ? enabledPlugins.has(metadata.name) : true);
-	const helpService = ctx.services?.help;
-	const aiService = ctx.services?.ai;
+	const helpService = ctx.services.help;
+	const aiService = ctx.services.ai;
 	if (helpService) {
 		let helpCount = 0;
 		for (const metadata of pluginMetadata) {
 			if (!metadata.config.help) continue;
+			if (!hasPublicKeyword(metadata.packageJson?.keywords)) continue;
 			helpService.registerHelp(metadata.name, metadata.config.help);
 			helpCount += 1;
 		}
@@ -459,7 +439,7 @@ async function registerPluginArtifacts(ctx) {
 				skillCount += 1;
 			}
 		} catch (error) {
-			logger.error(`[plugin-artifacts] Failed to load skills for plugin ${metadata.name}: ${error?.message || error}`);
+			logger.error(`[plugin-artifacts] Failed to load skills for plugin ${metadata.name}: ${error}`);
 		}
 	}
 	logger.info(`[plugin-artifacts] Registered ${skillCount} skill(s)`);
@@ -469,136 +449,97 @@ async function registerPluginArtifacts(ctx) {
 //#region src/core/service-config.ts
 const SERVICE_CONFIG_ROOT = "service";
 function resolveConfigDir(serviceName) {
-	return node_path.join(process.cwd(), "config", SERVICE_CONFIG_ROOT, serviceName);
+	return path.join(process.cwd(), "config", SERVICE_CONFIG_ROOT, serviceName);
 }
 function resolveConfigPath(serviceName, configName) {
-	return node_path.join(resolveConfigDir(serviceName), `${configName}.json`);
+	return path.join(resolveConfigDir(serviceName), `${configName}.json`);
 }
 function ensureDir(serviceName) {
 	const dir = resolveConfigDir(serviceName);
-	if (!node_fs.existsSync(dir)) node_fs.mkdirSync(dir, { recursive: true });
+	if (!(0, fs.existsSync)(dir)) (0, fs.mkdirSync)(dir, { recursive: true });
 }
-function registerServiceConfig(serviceName, configName, defaults) {
+async function registerServiceConfig(serviceName, configName, defaults) {
 	ensureDir(serviceName);
 	const configPath = resolveConfigPath(serviceName, configName);
-	if (!node_fs.existsSync(configPath)) node_fs.writeFileSync(configPath, JSON.stringify(defaults, null, 2), "utf-8");
+	if (!(0, fs.existsSync)(configPath)) await fs_promises.writeFile(configPath, JSON.stringify(defaults, null, 2), "utf-8");
 }
-function getServiceConfig(serviceName, configName) {
+async function getServiceConfig(serviceName, configName) {
 	const configPath = resolveConfigPath(serviceName, configName);
 	try {
-		if (node_fs.existsSync(configPath)) return JSON.parse(node_fs.readFileSync(configPath, "utf-8"));
-	} catch {}
-	return {};
+		return JSON.parse(await fs_promises.readFile(configPath, "utf-8"));
+	} catch (error) {
+		if (!(0, fs.existsSync)(configPath)) return {};
+		logger.warn(`[service-config] 读取 ${serviceName}/${configName} 失败: ${error}`);
+		return {};
+	}
 }
-function updateServiceConfig(serviceName, configName, value) {
+async function updateServiceConfig(serviceName, configName, value) {
 	ensureDir(serviceName);
-	node_fs.writeFileSync(resolveConfigPath(serviceName, configName), JSON.stringify(value, null, 2), "utf-8");
+	await fs_promises.writeFile(resolveConfigPath(serviceName, configName), JSON.stringify(value, null, 2), "utf-8");
 }
-function getServiceConfigs(serviceName) {
+async function getServiceConfigs(serviceName) {
 	const dir = resolveConfigDir(serviceName);
-	if (!node_fs.existsSync(dir)) return {};
+	if (!(0, fs.existsSync)(dir)) return {};
 	const result = {};
-	const files = node_fs.readdirSync(dir).filter((name) => name.endsWith(".json"));
-	for (const file of files) {
-		const filePath = node_path.join(dir, file);
-		try {
-			result[node_path.basename(file, ".json")] = JSON.parse(node_fs.readFileSync(filePath, "utf-8"));
-		} catch {}
+	const files = (await fs_promises.readdir(dir)).filter((name) => name.endsWith(".json"));
+	for (const file of files) try {
+		result[path.basename(file, ".json")] = JSON.parse(await fs_promises.readFile(path.join(dir, file), "utf-8"));
+	} catch (error) {
+		logger.warn(`[service-config] 读取 ${serviceName}/${file} 失败: ${error}`);
 	}
 	return result;
 }
-function deleteServiceConfig(serviceName, configName) {
+async function deleteServiceConfig(serviceName, configName) {
 	const configPath = resolveConfigPath(serviceName, configName);
-	if (!node_fs.existsSync(configPath)) return false;
-	node_fs.unlinkSync(configPath);
+	if (!(0, fs.existsSync)(configPath)) return false;
+	await fs_promises.unlink(configPath);
 	return true;
 }
 
 //#endregion
-//#region src/service-types.ts
+//#region src/types.ts
 const TOOL_RESULT_FOLLOWUP_KEY = "__miokuFollowup";
 
 //#endregion
 //#region src/core/data-paths.ts
-/**
-* Get the data directory for a specific plugin
-* Returns: {cwd}/data/{pluginName}
-*/
 function getPluginDataDir(pluginName) {
-	const dataDir = path.join(process.cwd(), "data", pluginName);
-	return dataDir;
+	return path.join(process.cwd(), "data", pluginName);
 }
-/**
-* Get the data directory for a service
-* Returns: {cwd}/data/{serviceName}
-*/
 function getServiceDataDir(serviceName) {
-	const dataDir = path.join(process.cwd(), "data", serviceName);
-	return dataDir;
+	return path.join(process.cwd(), "data", serviceName);
 }
-/**
-* Get the main data directory
-* Returns: {cwd}/data
-*/
 function getDataDir() {
 	return path.join(process.cwd(), "data");
 }
-/**
-* Get the config directory for a plugin
-* Returns: {cwd}/config/{pluginName}
-*/
 function getPluginConfigDir(pluginName) {
-	const configDir = path.join(process.cwd(), "config", pluginName);
-	return configDir;
+	return path.join(process.cwd(), "config", pluginName);
 }
-/**
-* Get the config directory for a service
-* Returns: {cwd}/config/service/{serviceName}
-*/
 function getServiceConfigDir(serviceName) {
-	const configDir = path.join(process.cwd(), "config", "service", serviceName);
-	return configDir;
+	return path.join(process.cwd(), "config", "service", serviceName);
 }
-/**
-* Get the main config directory
-* Returns: {cwd}/config
-*/
 function getConfigDir() {
 	return path.join(process.cwd(), "config");
 }
-/**
-* Ensure a directory exists, creating it if necessary
-*/
 function ensureDataDir(pluginName) {
 	const dir = getPluginDataDir(pluginName);
-	const { existsSync: existsSync$2, mkdirSync: mkdirSync$3 } = require("fs");
-	if (!existsSync$2(dir)) mkdirSync$3(dir, { recursive: true });
+	if (!(0, fs.existsSync)(dir)) (0, fs.mkdirSync)(dir, { recursive: true });
 	return dir;
 }
 
 //#endregion
 //#region src/core/plugin-runtime-state.ts
-const runtimeState = {};
-/**
-* Get the runtime state for a plugin
-*/
+const store = getOrCreate("plugin-runtime-state", () => ({}));
 function getPluginRuntimeState(pluginName) {
-	if (!runtimeState[pluginName]) runtimeState[pluginName] = {};
-	return runtimeState[pluginName];
+	if (!store[pluginName]) store[pluginName] = {};
+	return store[pluginName];
 }
-/**
-* Set/update the runtime state for a plugin
-*/
 function setPluginRuntimeState(pluginName, state) {
-	if (!runtimeState[pluginName]) runtimeState[pluginName] = {};
-	Object.assign(runtimeState[pluginName], state);
-	return runtimeState[pluginName];
+	if (!store[pluginName]) store[pluginName] = {};
+	Object.assign(store[pluginName], state);
+	return store[pluginName];
 }
-/**
-* Reset the runtime state for a plugin
-*/
 function resetPluginRuntimeState(pluginName) {
-	delete runtimeState[pluginName];
+	delete store[pluginName];
 }
 
 //#endregion
@@ -606,48 +547,31 @@ function resetPluginRuntimeState(pluginName) {
 function definePlugin(plugin) {
 	return plugin;
 }
-/**
-* Start Mioku with plugin and service discovery
-*/
 async function start(options = {}) {
 	const { cwd = process.cwd() } = options;
 	if (cwd) process.chdir(cwd);
-	const { start: startMioki, logger: logger$1, botConfig } = await import("mioki");
+	const { start: startMioki, logger: logger$1, botConfig: botConfig$1 } = await import("mioki");
 	setMiokuLogger(logger$1);
-	const packageJsonPath = path.join(process.cwd(), "package.json");
-	let miokuConfig = {};
-	if (fs.existsSync(packageJsonPath)) {
-		const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-		miokuConfig = pkg.mioki || {};
-	}
 	logger$1.info("こんにちは..");
 	logger$1.info("---------------------------------------");
 	logger$1.info("----------  Mioku 正在启动 ------------");
 	logger$1.info("---------------------------------------");
-	const requiredDirs = [
-		"data",
-		"config",
-		"temp"
-	];
-	for (const dir of requiredDirs) if (!(0, fs.existsSync)(dir)) (0, fs.mkdirSync)(dir, { recursive: true });
-	logger$1.info("O.o Miku 正在翻找插件..");
-	const discoveredPlugins = await plugin_manager_default.discoverPlugins(miokuConfig);
-	logger$1.info(`O.o 共发现 ${discoveredPlugins.length} 个插件: ${discoveredPlugins.map((p) => p.name).join(", ")}`);
-	const runtimePluginsDir = path.resolve(process.cwd(), DEFAULT_RUNTIME_PLUGINS_DIR);
-	const linkedPluginNames = await prepareRuntimePluginLinks(discoveredPlugins, runtimePluginsDir);
-	botConfig.plugins_dir = DEFAULT_RUNTIME_PLUGINS_DIR;
-	logger$1.info("o.O Miku 正在翻找服务..");
-	await service_manager_default.discoverServices(miokuConfig);
-	const requiredServices = plugin_manager_default.collectRequiredServices();
-	const missingServices = await service_manager_default.checkMissingServices(requiredServices);
-	if (missingServices.length > 0) logger$1.warn(`发现缺失服务: ${missingServices.join(", ")}`);
-	const userSpecifiedPlugins = miokuConfig.plugins !== void 0;
-	if (!userSpecifiedPlugins) {
-		for (const name of linkedPluginNames) if (!botConfig.plugins.includes(name)) botConfig.plugins.push(name);
+	await bootstrapMioku({
+		cwd,
+		botConfig: botConfig$1,
+		startMioki
+	});
+}
+function readVersion() {
+	try {
+		const here = path.dirname((0, url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+		const pkgPath = path.join(here, "..", "package.json");
+		return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version ?? "0.0.0";
+	} catch {
+		return "0.0.0";
 	}
-	await startMioki({ cwd });
 }
-const version = "1.0.0";
+const version = readVersion();
 
 //#endregion
 exports.TOOL_RESULT_FOLLOWUP_KEY = TOOL_RESULT_FOLLOWUP_KEY;