mioku 0.9.1 → 0.9.2

package/dist/index.js

@@ -1,15 +1,17 @@
 import { createRequire } from "node:module";
+import * as fs$2 from "node:fs";
+import * as path$3 from "node:path";
+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 * 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 * as fs$1 from "fs";
 import { existsSync, mkdirSync } from "fs";
 
 //#region rolldown:runtime
@@ -41,7 +43,7 @@ const logger = {
 const DEFAULT_RUNTIME_PLUGINS_DIR = ".mioku/plugins";
 async function pathExists$3(filePath) {
 	try {
-		await fs$4.access(filePath);
+		await fs$6.access(filePath);
 		return true;
 	} catch {
 		return false;
@@ -50,41 +52,41 @@ async function pathExists$3(filePath) {
 async function removeIfBrokenSymlink(entryPath) {
 	let stat;
 	try {
-		stat = await fs$4.lstat(entryPath);
+		stat = await fs$6.lstat(entryPath);
 	} catch {
 		return "removed";
 	}
 	if (!stat.isSymbolicLink()) return "blocked";
 	try {
-		await fs$4.realpath(entryPath);
+		await fs$6.realpath(entryPath);
 		return "ok";
 	} catch {
-		await fs$4.rm(entryPath, { force: true });
+		await fs$6.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);
+	const relativePath = path$7.relative(path$7.dirname(linkPath), targetPath);
 	return relativePath || ".";
 }
 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$6.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$6.realpath(linkPath);
+		const expectedTarget = await fs$6.realpath(targetPath);
 		if (currentTarget === expectedTarget) return true;
-		await fs$4.rm(linkPath, { force: true });
+		await fs$6.rm(linkPath, { force: true });
 		logger.info(`[plugin-linker] Rebuilding plugin link: ${metadata.name}`);
 	} catch {
-		await fs$4.rm(linkPath, { force: true });
+		await fs$6.rm(linkPath, { force: true });
 		logger.warn(`[plugin-linker] Removed broken plugin link: ${linkPath}`);
 	}
 	else if (stat) {
@@ -95,20 +97,20 @@ async function ensurePluginLink(runtimePluginsDir, metadata) {
 		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$6.symlink(targetPath, linkPath, "junction");
+	else await fs$6.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 });
+async function prepareRuntimePluginLinks(plugins, runtimePluginsDir = path$7.resolve(process.cwd(), DEFAULT_RUNTIME_PLUGINS_DIR)) {
+	await fs$6.mkdir(runtimePluginsDir, { recursive: true });
 	const discoveredNames = new Set(plugins.map((plugin) => plugin.name));
-	const entries = await fs$4.readdir(runtimePluginsDir, { withFileTypes: true });
+	const entries = await fs$6.readdir(runtimePluginsDir, { withFileTypes: true });
 	for (const entry of entries) {
-		const entryPath = path$5.join(runtimePluginsDir, entry.name);
+		const entryPath = path$7.join(runtimePluginsDir, entry.name);
 		const symlinkState = await removeIfBrokenSymlink(entryPath);
 		if (symlinkState !== "ok") continue;
 		if (entry.isSymbolicLink() && !discoveredNames.has(entry.name)) {
-			await fs$4.rm(entryPath, { force: true });
+			await fs$6.rm(entryPath, { force: true });
 			logger.info(`[plugin-linker] Removed stale plugin link: ${entry.name}`);
 		}
 	}
@@ -122,7 +124,7 @@ async function prepareRuntimePluginLinks(plugins, runtimePluginsDir = path$5.res
 const PLUGIN_MANAGER_SYMBOL = Symbol.for("mioku.plugin-manager");
 async function pathExists$2(filePath) {
 	try {
-		await fs$3.access(filePath);
+		await fs$5.access(filePath);
 		return true;
 	} catch {
 		return false;
@@ -142,7 +144,7 @@ var PluginManager = class 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");
+		const pluginsDir = configuredPluginsDir && configuredPluginsDir !== DEFAULT_RUNTIME_PLUGINS_DIR ? path$6.resolve(process.cwd(), configuredPluginsDir) : path$6.resolve(process.cwd(), "plugins");
 		this.pluginMetadata.clear();
 		if (!await pathExists$2(pluginsDir)) mkdirSync(pluginsDir, { recursive: true });
 		const discovered = [];
@@ -158,9 +160,9 @@ var PluginManager = class PluginManager {
 	async discoverFromDir(pluginsDir) {
 		const discovered = [];
 		try {
-			const entries = await fs$3.readdir(pluginsDir, { withFileTypes: true });
+			const entries = await fs$5.readdir(pluginsDir, { withFileTypes: true });
 			for (const entry of entries) {
-				const pluginPath = path$4.join(pluginsDir, entry.name);
+				const pluginPath = path$6.join(pluginsDir, entry.name);
 				const metadataPath = await this.resolveDirectoryPath(pluginPath);
 				if (!metadataPath) continue;
 				const metadata = await this.loadPluginMetadata(entry.name, pluginPath);
@@ -176,14 +178,14 @@ var PluginManager = class PluginManager {
 	}
 	async discoverFromNodeModules() {
 		const discovered = [];
-		const nodeModulesPath = path$4.resolve(process.cwd(), "node_modules");
+		const nodeModulesPath = path$6.resolve(process.cwd(), "node_modules");
 		if (!await pathExists$2(nodeModulesPath)) return discovered;
 		try {
-			const entries = await fs$3.readdir(nodeModulesPath, { withFileTypes: true });
+			const entries = await fs$5.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 pluginPath = path$6.join(nodeModulesPath, entry.name);
 				const metadata = await this.loadPluginMetadata(pluginName, pluginPath);
 				if (metadata) {
 					discovered.push(metadata);
@@ -197,7 +199,7 @@ var PluginManager = class PluginManager {
 	}
 	async resolveDirectoryPath(entryPath) {
 		try {
-			const stat = await fs$3.stat(entryPath);
+			const stat = await fs$5.stat(entryPath);
 			return stat.isDirectory() ? entryPath : null;
 		} catch {
 			return null;
@@ -206,12 +208,12 @@ var PluginManager = class PluginManager {
 	async loadPluginMetadata(name, pluginPath) {
 		let resolvedPath = pluginPath;
 		try {
-			resolvedPath = await fs$3.realpath(pluginPath);
+			resolvedPath = await fs$5.realpath(pluginPath);
 		} catch {}
-		const packageJsonPath = path$4.join(resolvedPath, "package.json");
+		const packageJsonPath = path$6.join(resolvedPath, "package.json");
 		let packageJson = null;
 		try {
-			const content = await fs$3.readFile(packageJsonPath, "utf-8");
+			const content = await fs$5.readFile(packageJsonPath, "utf-8");
 			packageJson = JSON.parse(content);
 		} catch {}
 		const metadata = {
@@ -246,7 +248,7 @@ var plugin_manager_default = PluginManager.getInstance();
 const SERVICE_MANAGER_SYMBOL = Symbol.for("mioku.service-manager");
 async function pathExists$1(filePath) {
 	try {
-		await fs$2.access(filePath);
+		await fs$4.access(filePath);
 		return true;
 	} catch {
 		return false;
@@ -265,8 +267,8 @@ var ServiceManager = class ServiceManager {
 		return g[SERVICE_MANAGER_SYMBOL];
 	}
 	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");
+		if (miokuConfig.services_dir) this.servicesDir = path$5.resolve(process.cwd(), miokuConfig.services_dir);
+		else this.servicesDir = path$5.resolve(process.cwd(), "services");
 		const discovered = [];
 		this.serviceMetadata.clear();
 		if (existsSync(this.servicesDir)) {
@@ -280,10 +282,10 @@ var ServiceManager = class ServiceManager {
 	async discoverFromDir(servicesDir) {
 		const discovered = [];
 		try {
-			const entries = await fs$2.readdir(servicesDir, { withFileTypes: true });
+			const entries = await fs$4.readdir(servicesDir, { withFileTypes: true });
 			for (const entry of entries) {
 				if (!entry.isDirectory()) continue;
-				const servicePath = path$3.join(servicesDir, entry.name);
+				const servicePath = path$5.join(servicesDir, entry.name);
 				const metadata = await this.loadServiceMetadata(entry.name, servicePath);
 				if (metadata) {
 					discovered.push(metadata);
@@ -298,12 +300,12 @@ var ServiceManager = class ServiceManager {
 	async loadServiceMetadata(name, servicePath) {
 		let resolvedPath = servicePath;
 		try {
-			resolvedPath = await fs$2.realpath(servicePath);
+			resolvedPath = await fs$4.realpath(servicePath);
 		} catch {}
-		const packageJsonPath = path$3.join(resolvedPath, "package.json");
+		const packageJsonPath = path$5.join(resolvedPath, "package.json");
 		if (!await pathExists$1(packageJsonPath)) return null;
 		try {
-			const packageJson = JSON.parse(await fs$2.readFile(packageJsonPath, "utf-8"));
+			const packageJson = JSON.parse(await fs$4.readFile(packageJsonPath, "utf-8"));
 			const metadata = {
 				name,
 				version: packageJson.version || "0.0.0",
@@ -324,14 +326,14 @@ var ServiceManager = class ServiceManager {
 		await this.discoverFromNodeModules();
 	}
 	async discoverFromNodeModules() {
-		const nodeModulesPath = path$3.resolve(process.cwd(), "node_modules");
+		const nodeModulesPath = path$5.resolve(process.cwd(), "node_modules");
 		if (!await pathExists$1(nodeModulesPath)) return;
 		try {
-			const entries = await fs$2.readdir(nodeModulesPath, { withFileTypes: true });
+			const entries = await fs$4.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 servicePath = path$5.join(nodeModulesPath, entry.name);
 				const metadata = await this.loadServiceMetadata(serviceName, servicePath);
 				if (metadata) this.serviceMetadata.set(serviceName, metadata);
 			}
@@ -351,8 +353,8 @@ var ServiceManager = class ServiceManager {
 	}
 	async loadService(metadata, ctx) {
 		try {
-			const indexPath = path$3.join(metadata.path, "index.ts");
-			const indexJsPath = path$3.join(metadata.path, "index.js");
+			const indexPath = path$5.join(metadata.path, "index.ts");
+			const indexJsPath = path$5.join(metadata.path, "index.js");
 			const indexExists = await pathExists$1(indexPath);
 			const indexJsExists = await pathExists$1(indexJsPath);
 			const entryPoint = indexExists ? indexPath : indexJsPath;
@@ -404,7 +406,7 @@ var service_manager_default = ServiceManager.getInstance();
 //#region src/core/plugin-artifact-registry.ts
 async function pathExists(filePath) {
 	try {
-		await fs$1.access(filePath);
+		await fs$3.access(filePath);
 		return true;
 	} catch {
 		return false;
@@ -430,9 +432,9 @@ function extractSkills(moduleExports) {
 	return [];
 }
 async function resolveSkillsEntry(pluginPath) {
-	const tsPath = path$2.join(pluginPath, "skills.ts");
+	const tsPath = path$4.join(pluginPath, "skills.ts");
 	if (await pathExists(tsPath)) return tsPath;
-	const jsPath = path$2.join(pluginPath, "skills.js");
+	const jsPath = path$4.join(pluginPath, "skills.js");
 	if (await pathExists(jsPath)) return jsPath;
 	return null;
 }
@@ -462,7 +464,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$4.basename(skillsEntry)} but exported no valid skill`);
 				continue;
 			}
 			for (const skill of skills) {
@@ -476,6 +478,55 @@ async function registerPluginArtifacts(ctx) {
 	logger.info(`[plugin-artifacts] Registered ${skillCount} skill(s)`);
 }
 
+//#endregion
+//#region src/core/service-config.ts
+const SERVICE_CONFIG_ROOT = "service";
+function resolveConfigDir(serviceName) {
+	return path$3.join(process.cwd(), "config", SERVICE_CONFIG_ROOT, serviceName);
+}
+function resolveConfigPath(serviceName, configName) {
+	return path$3.join(resolveConfigDir(serviceName), `${configName}.json`);
+}
+function ensureDir(serviceName) {
+	const dir = resolveConfigDir(serviceName);
+	if (!fs$2.existsSync(dir)) fs$2.mkdirSync(dir, { recursive: true });
+}
+function registerServiceConfig(serviceName, configName, defaults) {
+	ensureDir(serviceName);
+	const configPath = resolveConfigPath(serviceName, configName);
+	if (!fs$2.existsSync(configPath)) fs$2.writeFileSync(configPath, JSON.stringify(defaults, null, 2), "utf-8");
+}
+function getServiceConfig(serviceName, configName) {
+	const configPath = resolveConfigPath(serviceName, configName);
+	try {
+		if (fs$2.existsSync(configPath)) return JSON.parse(fs$2.readFileSync(configPath, "utf-8"));
+	} catch {}
+	return {};
+}
+function updateServiceConfig(serviceName, configName, value) {
+	ensureDir(serviceName);
+	fs$2.writeFileSync(resolveConfigPath(serviceName, configName), JSON.stringify(value, null, 2), "utf-8");
+}
+function getServiceConfigs(serviceName) {
+	const dir = resolveConfigDir(serviceName);
+	if (!fs$2.existsSync(dir)) return {};
+	const result = {};
+	const files = fs$2.readdirSync(dir).filter((name) => name.endsWith(".json"));
+	for (const file of files) {
+		const filePath = path$3.join(dir, file);
+		try {
+			result[path$3.basename(file, ".json")] = JSON.parse(fs$2.readFileSync(filePath, "utf-8"));
+		} catch {}
+	}
+	return result;
+}
+function deleteServiceConfig(serviceName, configName) {
+	const configPath = resolveConfigPath(serviceName, configName);
+	if (!fs$2.existsSync(configPath)) return false;
+	fs$2.unlinkSync(configPath);
+	return true;
+}
+
 //#endregion
 //#region src/service-types.ts
 const TOOL_RESULT_FOLLOWUP_KEY = "__miokuFollowup";
@@ -487,7 +538,7 @@ const TOOL_RESULT_FOLLOWUP_KEY = "__miokuFollowup";
 * Returns: {cwd}/data/{pluginName}
 */
 function getPluginDataDir(pluginName) {
-	const dataDir = path$1.join(process.cwd(), "data", pluginName);
+	const dataDir = path$2.join(process.cwd(), "data", pluginName);
 	return dataDir;
 }
 /**
@@ -495,7 +546,7 @@ function getPluginDataDir(pluginName) {
 * Returns: {cwd}/data/{serviceName}
 */
 function getServiceDataDir(serviceName) {
-	const dataDir = path$1.join(process.cwd(), "data", serviceName);
+	const dataDir = path$2.join(process.cwd(), "data", serviceName);
 	return dataDir;
 }
 /**
@@ -503,22 +554,22 @@ function getServiceDataDir(serviceName) {
 * Returns: {cwd}/data
 */
 function getDataDir() {
-	return path$1.join(process.cwd(), "data");
+	return path$2.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);
+	const configDir = path$2.join(process.cwd(), "config", pluginName);
 	return configDir;
 }
 /**
 * Get the config directory for a service
-* Returns: {cwd}/config/{serviceName}
+* Returns: {cwd}/config/service/{serviceName}
 */
 function getServiceConfigDir(serviceName) {
-	const configDir = path$1.join(process.cwd(), "config", serviceName);
+	const configDir = path$2.join(process.cwd(), "config", "service", serviceName);
 	return configDir;
 }
 /**
@@ -526,7 +577,7 @@ function getServiceConfigDir(serviceName) {
 * Returns: {cwd}/config
 */
 function getConfigDir() {
-	return path$1.join(process.cwd(), "config");
+	return path$2.join(process.cwd(), "config");
 }
 /**
 * Ensure a directory exists, creating it if necessary
@@ -576,10 +627,10 @@ async function start(options = {}) {
 	if (cwd) process.chdir(cwd);
 	const { start: startMioki, logger: logger$1, botConfig } = await import("mioki");
 	setMiokuLogger(logger$1);
-	const packageJsonPath = path.join(process.cwd(), "package.json");
+	const packageJsonPath = path$1.join(process.cwd(), "package.json");
 	let miokuConfig = {};
-	if (fs.existsSync(packageJsonPath)) {
-		const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+	if (fs$1.existsSync(packageJsonPath)) {
+		const pkg = JSON.parse(fs$1.readFileSync(packageJsonPath, "utf-8"));
 		miokuConfig = pkg.mioki || {};
 	}
 	logger$1.info("こんにちは..");
@@ -595,7 +646,7 @@ async function start(options = {}) {
 	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 runtimePluginsDir = path$1.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 正在翻找服务..");
@@ -612,5 +663,5 @@ async function start(options = {}) {
 const version = "1.0.0";
 
 //#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