mioku 0.9.1 → 0.9.3

package/dist/index.js

@@ -1,21 +1,23 @@
-import { createRequire } from "node:module";
-import * as fs$4 from "fs/promises";
-import * as fs$3 from "fs/promises";
-import * as fs$2 from "fs/promises";
-import * as fs$1 from "fs/promises";
+import * as fs from "fs";
+import { existsSync, mkdirSync } from "fs";
+import * as path$8 from "path";
+import * as path$7 from "path";
+import * as path$6 from "path";
 import * as path$5 from "path";
 import * as path$4 from "path";
 import * as path$3 from "path";
 import * as path$2 from "path";
 import * as path$1 from "path";
 import * as path from "path";
-import * as fs from "fs";
-import { existsSync, mkdirSync } from "fs";
-
-//#region rolldown:runtime
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+import { fileURLToPath } from "url";
+import * as fs$6 from "fs/promises";
+import * as fs$5 from "fs/promises";
+import * as fs$4 from "fs/promises";
+import * as fs$3 from "fs/promises";
+import * as fs$2 from "fs/promises";
+import * as fs$1 from "fs/promises";
+import { botConfig } from "mioki";
 
-//#endregion
 //#region src/core/logger.ts
 const fallbackLogger = {
 	error: (...args) => console.error(...args),
@@ -37,78 +39,135 @@ 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$4.access(filePath);
+		await fs$6.access(filePath);
 		return true;
 	} catch {
 		return false;
 	}
 }
+async function resolveRealpath(p) {
+	try {
+		return await fs$6.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$6.readdir(dir, { withFileTypes: true });
+	} catch {
+		return results;
+	}
+	for (const entry of entries) {
+		const entryPath = path$8.join(dir, entry.name);
+		try {
+			const stat = await fs$6.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$8.resolve(process.cwd(), "node_modules");
+	if (!await pathExists(nodeModulesPath)) return results;
+	let entries;
+	try {
+		entries = await fs$6.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$8.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 {
-		stat = await fs$4.lstat(entryPath);
+		stat = await fs$5.lstat(entryPath);
 	} catch {
 		return "removed";
 	}
 	if (!stat.isSymbolicLink()) return "blocked";
 	try {
-		await fs$4.realpath(entryPath);
+		await fs$5.realpath(entryPath);
 		return "ok";
 	} catch {
-		await fs$4.rm(entryPath, { force: true });
+		await fs$5.rm(entryPath, { force: true });
 		logger.warn(`[plugin-linker] Removed broken plugin link: ${entryPath}`);
 		return "removed";
 	}
 }
 function relativeSymlinkTarget(linkPath, targetPath) {
-	const relativePath = path$5.relative(path$5.dirname(linkPath), targetPath);
-	return relativePath || ".";
+	return path$7.relative(path$7.dirname(linkPath), targetPath) || ".";
 }
 async function ensurePluginLink(runtimePluginsDir, metadata) {
-	const linkPath = path$5.join(runtimePluginsDir, metadata.name);
+	const linkPath = path$7.join(runtimePluginsDir, metadata.name);
 	const targetPath = metadata.path;
 	let stat;
 	try {
-		stat = await fs$4.lstat(linkPath);
+		stat = await fs$5.lstat(linkPath);
 	} catch {
 		stat = null;
 	}
 	if (stat?.isSymbolicLink()) try {
-		const currentTarget = await fs$4.realpath(linkPath);
-		const expectedTarget = await fs$4.realpath(targetPath);
+		const currentTarget = await fs$5.realpath(linkPath);
+		const expectedTarget = await fs$5.realpath(targetPath);
 		if (currentTarget === expectedTarget) return true;
-		await fs$4.rm(linkPath, { force: true });
+		await fs$5.rm(linkPath, { force: true });
 		logger.info(`[plugin-linker] Rebuilding plugin link: ${metadata.name}`);
 	} catch {
-		await fs$4.rm(linkPath, { force: true });
+		await fs$5.rm(linkPath, { force: true });
 		logger.warn(`[plugin-linker] Removed broken plugin link: ${linkPath}`);
 	}
 	else if (stat) {
 		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;
 	}
-	if (process.platform === "win32") await fs$4.symlink(targetPath, linkPath, "junction");
-	else await fs$4.symlink(relativeSymlinkTarget(linkPath, targetPath), linkPath, "dir");
+	if (process.platform === "win32") await fs$5.symlink(targetPath, linkPath, "junction");
+	else await fs$5.symlink(relativeSymlinkTarget(linkPath, targetPath), linkPath, "dir");
 	return true;
 }
-async function prepareRuntimePluginLinks(plugins, runtimePluginsDir = path$5.resolve(process.cwd(), DEFAULT_RUNTIME_PLUGINS_DIR)) {
-	await fs$4.mkdir(runtimePluginsDir, { recursive: true });
-	const discoveredNames = new Set(plugins.map((plugin) => plugin.name));
-	const entries = await fs$4.readdir(runtimePluginsDir, { withFileTypes: true });
+async function prepareRuntimePluginLinks(plugins, runtimePluginsDir = path$7.resolve(process.cwd(), DEFAULT_RUNTIME_PLUGINS_DIR)) {
+	await fs$5.mkdir(runtimePluginsDir, { recursive: true });
+	const discoveredNames = new Set(plugins.map((p) => p.name));
+	const entries = await fs$5.readdir(runtimePluginsDir, { withFileTypes: true });
 	for (const entry of entries) {
-		const entryPath = path$5.join(runtimePluginsDir, entry.name);
-		const symlinkState = await removeIfBrokenSymlink(entryPath);
-		if (symlinkState !== "ok") continue;
+		const entryPath = path$7.join(runtimePluginsDir, entry.name);
+		if (await removeIfBrokenSymlink(entryPath) !== "ok") continue;
 		if (entry.isSymbolicLink() && !discoveredNames.has(entry.name)) {
-			await fs$4.rm(entryPath, { force: true });
+			await fs$5.rm(entryPath, { force: true });
 			logger.info(`[plugin-linker] Removed stale plugin link: ${entry.name}`);
 		}
 	}
@@ -118,279 +177,166 @@ async function prepareRuntimePluginLinks(plugins, runtimePluginsDir = path$5.res
 }
 
 //#endregion
-//#region src/core/plugin-manager.ts
-const PLUGIN_MANAGER_SYMBOL = Symbol.for("mioku.plugin-manager");
-async function pathExists$2(filePath) {
-	try {
-		await fs$3.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$4.resolve(process.cwd(), configuredPluginsDir) : path$4.resolve(process.cwd(), "plugins");
-		this.pluginMetadata.clear();
-		if (!await pathExists$2(pluginsDir)) mkdirSync(pluginsDir, { recursive: true });
-		const discovered = [];
-		if (await pathExists$2(pluginsDir)) {
-			const localPlugins = await this.discoverFromDir(pluginsDir);
-			discovered.push(...localPlugins);
+		const configuredDir = miokuConfig.plugins_dir;
+		const pluginsDir = configuredDir && configuredDir !== DEFAULT_RUNTIME_PLUGINS_DIR ? path$6.resolve(process.cwd(), configuredDir) : path$6.resolve(process.cwd(), "plugins");
+		this.plugins.clear();
+		if (!await pathExists(pluginsDir)) 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);
 		}
-		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$3.readdir(pluginsDir, { withFileTypes: true });
-			for (const entry of entries) {
-				const pluginPath = path$4.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}`);
-		}
-		return discovered;
-	}
-	async discoverFromNodeModules() {
-		const discovered = [];
-		const nodeModulesPath = path$4.resolve(process.cwd(), "node_modules");
-		if (!await pathExists$2(nodeModulesPath)) return discovered;
-		try {
-			const entries = await fs$3.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$4.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$3.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$3.realpath(pluginPath);
-		} catch {}
-		const packageJsonPath = path$4.join(resolvedPath, "package.json");
+		const resolvedPath = await resolveRealpath(pluginPath);
 		let packageJson = null;
 		try {
-			const content = await fs$3.readFile(packageJsonPath, "utf-8");
-			packageJson = JSON.parse(content);
-		} catch {}
-		const metadata = {
+			packageJson = JSON.parse(await fs$4.readFile(path$6.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$2.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$3.resolve(process.cwd(), miokuConfig.services_dir);
-		else this.servicesDir = path$3.resolve(process.cwd(), "services");
-		const discovered = [];
+		const servicesDir = miokuConfig.services_dir ? path$5.resolve(process.cwd(), miokuConfig.services_dir) : path$5.resolve(process.cwd(), "services");
 		this.serviceMetadata.clear();
-		if (existsSync(this.servicesDir)) {
-			const localServices = await this.discoverFromDir(this.servicesDir);
-			discovered.push(...localServices);
-		} else 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$2.readdir(servicesDir, { withFileTypes: true });
-			for (const entry of entries) {
-				if (!entry.isDirectory()) continue;
-				const servicePath = path$3.join(servicesDir, entry.name);
-				const metadata = await this.loadServiceMetadata(entry.name, servicePath);
-				if (metadata) {
-					discovered.push(metadata);
-					this.serviceMetadata.set(entry.name, metadata);
-				}
+		if (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 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$2.realpath(servicePath);
-		} catch {}
-		const packageJsonPath = path$3.join(resolvedPath, "package.json");
-		if (!await pathExists$1(packageJsonPath)) return null;
+		const packageJsonPath = path$5.join(servicePath, "package.json");
+		if (!await pathExists(packageJsonPath)) return null;
 		try {
-			const packageJson = JSON.parse(await fs$2.readFile(packageJsonPath, "utf-8"));
-			const metadata = {
+			const packageJson = JSON.parse(await fs$3.readFile(packageJsonPath, "utf-8"));
+			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$3.resolve(process.cwd(), "node_modules");
-		if (!await pathExists$1(nodeModulesPath)) return;
-		try {
-			const entries = await fs$2.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$3.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$3.join(metadata.path, "index.ts");
-			const indexJsPath = path$3.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$5.join(metadata.path, "index.ts");
+			const jsEntry = path$5.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() {
@@ -401,21 +347,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$4.join(process.cwd(), "package.json");
 	try {
-		await fs$1.access(filePath);
-		return true;
+		const pkg = JSON.parse(await fs$2.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 (!existsSync(dir)) 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$4.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 = [
@@ -430,20 +411,17 @@ function extractSkills(moduleExports) {
 	return [];
 }
 async function resolveSkillsEntry(pluginPath) {
-	const tsPath = path$2.join(pluginPath, "skills.ts");
+	const tsPath = path$3.join(pluginPath, "skills.ts");
 	if (await pathExists(tsPath)) return tsPath;
-	const jsPath = path$2.join(pluginPath, "skills.js");
+	const jsPath = path$3.join(pluginPath, "skills.js");
 	if (await pathExists(jsPath)) return jsPath;
 	return null;
 }
-/**
-* Auto-register plugin help manifests and AI skills
-*/
 async function registerPluginArtifacts(ctx) {
-	const enabledPlugins = new Set(Array.isArray(ctx.botConfig?.plugins) ? ctx.botConfig.plugins : []);
+	const enabledPlugins = new Set(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) {
@@ -462,7 +440,7 @@ async function registerPluginArtifacts(ctx) {
 			const moduleExports = await import(toImportPath(skillsEntry));
 			const skills = extractSkills(moduleExports);
 			if (skills.length === 0) {
-				logger.warn(`[plugin-artifacts] Plugin ${metadata.name} has ${path$2.basename(skillsEntry)} but exported no valid skill`);
+				logger.warn(`[plugin-artifacts] Plugin ${metadata.name} has ${path$3.basename(skillsEntry)} but exported no valid skill`);
 				continue;
 			}
 			for (const skill of skills) {
@@ -470,97 +448,107 @@ 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)`);
 }
 
 //#endregion
-//#region src/service-types.ts
+//#region src/core/service-config.ts
+const SERVICE_CONFIG_ROOT = "service";
+function resolveConfigDir(serviceName) {
+	return path$2.join(process.cwd(), "config", SERVICE_CONFIG_ROOT, serviceName);
+}
+function resolveConfigPath(serviceName, configName) {
+	return path$2.join(resolveConfigDir(serviceName), `${configName}.json`);
+}
+function ensureDir(serviceName) {
+	const dir = resolveConfigDir(serviceName);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+async function registerServiceConfig(serviceName, configName, defaults) {
+	ensureDir(serviceName);
+	const configPath = resolveConfigPath(serviceName, configName);
+	if (!existsSync(configPath)) await fs$1.writeFile(configPath, JSON.stringify(defaults, null, 2), "utf-8");
+}
+async function getServiceConfig(serviceName, configName) {
+	const configPath = resolveConfigPath(serviceName, configName);
+	try {
+		return JSON.parse(await fs$1.readFile(configPath, "utf-8"));
+	} catch (error) {
+		if (!existsSync(configPath)) return {};
+		logger.warn(`[service-config] 读取 ${serviceName}/${configName} 失败: ${error}`);
+		return {};
+	}
+}
+async function updateServiceConfig(serviceName, configName, value) {
+	ensureDir(serviceName);
+	await fs$1.writeFile(resolveConfigPath(serviceName, configName), JSON.stringify(value, null, 2), "utf-8");
+}
+async function getServiceConfigs(serviceName) {
+	const dir = resolveConfigDir(serviceName);
+	if (!existsSync(dir)) return {};
+	const result = {};
+	const files = (await fs$1.readdir(dir)).filter((name) => name.endsWith(".json"));
+	for (const file of files) try {
+		result[path$2.basename(file, ".json")] = JSON.parse(await fs$1.readFile(path$2.join(dir, file), "utf-8"));
+	} catch (error) {
+		logger.warn(`[service-config] 读取 ${serviceName}/${file} 失败: ${error}`);
+	}
+	return result;
+}
+async function deleteServiceConfig(serviceName, configName) {
+	const configPath = resolveConfigPath(serviceName, configName);
+	if (!existsSync(configPath)) return false;
+	await fs$1.unlink(configPath);
+	return true;
+}
+
+//#endregion
+//#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$1.join(process.cwd(), "data", pluginName);
-	return dataDir;
+	return path$1.join(process.cwd(), "data", pluginName);
 }
-/**
-* Get the data directory for a service
-* Returns: {cwd}/data/{serviceName}
-*/
 function getServiceDataDir(serviceName) {
-	const dataDir = path$1.join(process.cwd(), "data", serviceName);
-	return dataDir;
+	return path$1.join(process.cwd(), "data", serviceName);
 }
-/**
-* Get the main data directory
-* Returns: {cwd}/data
-*/
 function getDataDir() {
 	return path$1.join(process.cwd(), "data");
 }
-/**
-* Get the config directory for a plugin
-* Returns: {cwd}/config/{pluginName}
-*/
 function getPluginConfigDir(pluginName) {
-	const configDir = path$1.join(process.cwd(), "config", pluginName);
-	return configDir;
+	return path$1.join(process.cwd(), "config", pluginName);
 }
-/**
-* Get the config directory for a service
-* Returns: {cwd}/config/{serviceName}
-*/
 function getServiceConfigDir(serviceName) {
-	const configDir = path$1.join(process.cwd(), "config", serviceName);
-	return configDir;
+	return path$1.join(process.cwd(), "config", "service", serviceName);
 }
-/**
-* Get the main config directory
-* Returns: {cwd}/config
-*/
 function getConfigDir() {
 	return path$1.join(process.cwd(), "config");
 }
-/**
-* Ensure a directory exists, creating it if necessary
-*/
 function ensureDataDir(pluginName) {
 	const dir = getPluginDataDir(pluginName);
-	const { existsSync: existsSync$1, mkdirSync: mkdirSync$1 } = __require("fs");
-	if (!existsSync$1(dir)) mkdirSync$1(dir, { recursive: true });
+	if (!existsSync(dir)) 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
@@ -568,49 +556,32 @@ 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 (!existsSync(dir)) 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(fileURLToPath(import.meta.url));
+		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
-export { TOOL_RESULT_FOLLOWUP_KEY, definePlugin, ensureDataDir, getConfigDir, getDataDir, getPluginConfigDir, getPluginDataDir, getPluginRuntimeState, getServiceConfigDir, getServiceDataDir, plugin_manager_default as pluginManager, registerPluginArtifacts, resetPluginRuntimeState, service_manager_default as serviceManager, setPluginRuntimeState, start, version };
+export { TOOL_RESULT_FOLLOWUP_KEY, definePlugin, deleteServiceConfig, ensureDataDir, getConfigDir, getDataDir, getPluginConfigDir, getPluginDataDir, getPluginRuntimeState, getServiceConfig, getServiceConfigDir, getServiceConfigs, getServiceDataDir, plugin_manager_default as pluginManager, registerPluginArtifacts, registerServiceConfig, resetPluginRuntimeState, service_manager_default as serviceManager, setPluginRuntimeState, start, updateServiceConfig, version };
 //# sourceMappingURL=index.js.map