@koishi-ce/plugin-config 1.0.0

package/lib/index.mjs

@@ -0,0 +1,518 @@
+import { createRequire } from "node:module";
+import { resolve } from "node:path";
+import { Context, Logger, Schema, remove } from "@koishi-ce/koishi";
+import { DataService } from "@koishi-ce/console";
+import { Loader } from "@koishi-ce/loader";
+import { LocalScanner } from "@koishi-ce/registry";
+//#region \0rolldown/runtime.js
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+//#region src/shared/packages.ts
+/**
+* 插件包元数据提供器（服务端共享实现）。
+*
+* 以 `packages` 数据服务的形式向浏览器端提供本机可用的插件包列表及
+* 各自的运行时信息（Config schema、用法文档、注入的服务依赖、fork
+* 状态等）。运行时信息通过解析插件模块的导出（parseExports）获得并
+* 缓存在 cache 中，监听 runtime/fork/status 等内部事件按需刷新。
+*
+* 抽象类只定义"运行时信息"这一半；列表如何收集（本机扫描还是市场
+* 数据）分别由 node / browser 两个运行环境的子类实现。
+*/
+const logger$2 = new Logger("config");
+var PackageProvider = class extends DataService {
+	cache = {};
+	debouncedRefresh;
+	ctx;
+	/**
+	* @param ctx 应用上下文
+	*/
+	constructor(ctx) {
+		super(ctx, "packages", { authority: 4 });
+		this.ctx = ctx;
+		this.debouncedRefresh = ctx.debounce(() => this.refresh(false), 0);
+		ctx.on("internal/runtime", (scope) => this.update(scope.runtime.plugin));
+		ctx.on("internal/fork", (scope) => this.update(scope.runtime.plugin));
+		ctx.on("internal/status", (scope) => this.update(scope.runtime.plugin));
+		ctx.on("hmr/reload", (reloads) => {
+			for (const [plugin] of reloads) this.update(plugin);
+		});
+		ctx.console.addListener("config/request-runtime", async (name) => {
+			name = name.replace(/(koishi-|^@koishijs\/)plugin-/, "");
+			this.cache[name] = await this.parseExports(name);
+			this.refresh(false);
+		}, { authority: 4 });
+	}
+	/**
+	* 某插件的运行时状态发生变化时，重新解析其导出并去抖刷新服务。
+	*
+	* @param plugin 发生变化的插件对象
+	*/
+	async update(plugin) {
+		const name = this.ctx.loader.keyFor(plugin);
+		if (!name || !this.cache[name]) return;
+		this.cache[name] = await this.parseExports(name);
+		this.debouncedRefresh();
+	}
+	/**
+	* 从插件主作用域提取 fork 运行状态，写入 result 的 id/forkable/forks 字段。
+	*
+	* @param state 插件的主作用域
+	* @param result 待填充的运行时数据（原地修改）
+	*/
+	parseRuntime(state, result) {
+		if (state.runtime.uid !== null) result.id = state.runtime.uid;
+		result.forkable = state.runtime.isForkable;
+		const forks = {};
+		for (const fork of state.children) {
+			const key = fork.key;
+			if (!key) continue;
+			forks[key] = { status: fork.status };
+		}
+		result.forks = forks;
+	}
+	/**
+	* 数据服务读取入口：收集包列表，合并缓存的运行时信息，
+	* 并在最前面附加一个 name 为空串的"应用全局设置"条目。
+	*/
+	async get(forced = false) {
+		const objects = (await this.collect(forced)).slice();
+		for (const object of objects) {
+			object.name = object.package?.name || "";
+			const cached = this.cache[object.shortname];
+			if (!cached) continue;
+			object.runtime = cached;
+		}
+		objects.unshift({
+			name: "",
+			runtime: { schema: Context.Config },
+			package: { name: "" }
+		});
+		return Object.fromEntries(objects.map((data) => [data.name, data]));
+	}
+	/**
+	* 解析插件模块的导出，提取配置 schema、用法文档、过滤器开关与
+	* 注入的服务依赖（required / optional），并附带运行时 fork 状态。
+	* 解析失败时返回 `{ failed: true }` 而不是抛错。
+	*
+	* @param name 插件短名（不含 koishi-plugin- 前缀）
+	* @returns 可序列化的运行时数据
+	*/
+	async parseExports(name) {
+		try {
+			const exports = await this.ctx.loader.resolve(name);
+			const result = {};
+			const schema = exports?.Config || exports?.schema;
+			if (schema) result.schema = schema;
+			if (exports?.usage) result.usage = exports.usage;
+			if (exports?.filter !== void 0) result.filter = exports.filter;
+			const inject = exports?.using || exports?.inject || [];
+			if (Array.isArray(inject)) {
+				result.required = inject;
+				result.optional = [];
+			} else {
+				result.required = inject.required || [];
+				result.optional = inject.optional || [];
+			}
+			JSON.stringify(result);
+			const runtime = exports ? this.ctx.registry.get(exports) : void 0;
+			if (runtime) this.parseRuntime(runtime, result);
+			return result;
+		} catch (error) {
+			logger$2.warn("failed to load %c", name);
+			logger$2.warn(error);
+			return { failed: true };
+		}
+	}
+};
+//#endregion
+//#region src/shared/services.ts
+/**
+* 服务状态提供器：以 `services` 数据服务的形式向浏览器端上报当前
+* 应用中每个已注册服务的提供者信息（服务名 → 提供该服务的上下文 uid）。
+* 前端据此判断某插件"必需/可选注入的服务"是否已可用。
+*
+* 遍历方式：从根上下文的 internal 对象出发沿原型链逐层收集类型为
+* "service" 的属性，再通过 Context.current 访问器反查服务实例所属的
+* 上下文，取其作用域 uid。
+*/
+var ServiceProvider = class extends DataService {
+	constructor(ctx) {
+		super(ctx, "services");
+		ctx.on("internal/service", () => this.refresh());
+	}
+	async get() {
+		const services = {};
+		/**
+		* 递归遍历 internal 对象的原型链，收集所有服务属性。
+		*
+		* @param internal 当前层级的 internal 对象
+		*/
+		const attach = (internal) => {
+			if (!internal) return;
+			attach(Object.getPrototypeOf(internal));
+			for (const [key, { type }] of Object.entries(internal)) {
+				if (type !== "service") continue;
+				const instance = this.ctx.get(key);
+				if (!(instance instanceof Object)) continue;
+				const ctx = Reflect.getOwnPropertyDescriptor(instance, Context.current)?.value;
+				if (!ctx) continue;
+				const name = key.replace(/^__/, "").replace(/__$/, "");
+				if (ctx.scope.uid !== null) services[name] = ctx.scope.uid;
+			}
+		};
+		attach(this.ctx.root[Context.internal]);
+		return services;
+	}
+};
+//#endregion
+//#region src/shared/writer.ts
+/**
+* 配置写入器（服务端共享实现）。
+*
+* 本模块是 config 插件的核心：以 `config` 数据服务的形式把 loader 中的
+* 应用配置（koishi.yml / koishi.json）推送到浏览器端控制台，并把前端
+* 发来的 `manager/*` 事件（重载、停用、移除、改名、拖拽移动等）落实为
+* 对内存中配置对象的修改，再由 loader.writeConfig() 持久化回配置文件。
+*
+* 由于 YAML/JSON 对象的键顺序即插件在配置文件中的书写顺序，本模块中的
+* 多个辅助函数（insertKey / rename / dropKey）都围绕"在保持键顺序的
+* 前提下增删改键"这一目标实现。
+*/
+const logger$1 = new Logger("loader");
+/**
+* 把 temp 中的键插入到 object 的开头（原有 rest 键依次后移），用于在
+* 不破坏其它键相对顺序的前提下完成"插入到指定位置"的配置操作。
+*
+* 实现方式是先把 rest 中的键全部搬到 temp 里，再用 Object.assign 合并回来。
+*
+* @param object 目标配置对象（会被原地修改）
+* @param temp 待插入的键值对
+* @param rest 需要让位的既有键名列表
+*/
+function insertKey(object, temp, rest) {
+	for (const key of rest) {
+		temp[key] = object[key];
+		delete object[key];
+	}
+	Object.assign(object, temp);
+}
+/**
+* 在对象中把键 old 重命名为 neo（并可顺带替换其值），且保持键原有的位置。
+*
+* @param object 目标配置对象
+* @param old 旧键名（可为 `"~" + name` 形式的停用态键）
+* @param neo 新键名
+* @param value 新键对应的值
+*/
+function rename(object, old, neo, value) {
+	const keys = Object.keys(object);
+	const index = keys.findIndex((key) => key === old || key === `~${old}`);
+	const rest = index < 0 ? [] : keys.slice(index + 1);
+	const temp = { [neo]: value };
+	delete object[old];
+	delete object[`~${old}`];
+	insertKey(object, temp, rest);
+}
+/**
+* 从 plugins 配置中摘除指定的键（兼容 `~` 前缀的停用态键），返回以该键
+* 为唯一成员的对象，便于随后通过 insertKey 插入到别处（teleport 场景）。
+*
+* @param plugins 插件配置对象
+* @param name 插件键名
+*/
+function dropKey(plugins, name) {
+	if (!(name in plugins)) name = `~${name}`;
+	const value = plugins[name];
+	delete plugins[name];
+	return { [name]: value };
+}
+/**
+* 配置写入器服务。以 `config` 为服务名向控制台暴露当前应用配置，
+* 并接收前端 `manager/*` 事件来修改配置文件。所有事件均要求
+* authority 达到 4（管理员）。
+*/
+var ConfigWriter = class extends DataService {
+	loader;
+	constructor(ctx) {
+		super(ctx, "config", { authority: 4 });
+		this.loader = ctx.loader;
+		ctx.console.addListener("manager/app-reload", (config) => {
+			return this.reloadApp(config);
+		}, { authority: 4 });
+		for (const key of [
+			"teleport",
+			"reload",
+			"unload",
+			"remove",
+			"meta"
+		]) ctx.console.addListener(`manager/${key}`, async (...args) => {
+			try {
+				await this[key].apply(this, args);
+			} catch (error) {
+				logger$1.error(error);
+				throw new Error("failed");
+			}
+		}, { authority: 4 });
+		ctx.on("config", () => this.refresh());
+	}
+	/**
+	* 递归过滤并整理某层上下文的插件配置，得到可安全下发给前端的副本。
+	*
+	* - 过滤掉内部保留键（`$` 开头，如 `$folded`）；
+	* - 剔除 `$if` 条件不成立的插件项（停用插件以 `~` 前缀 + `$if-disabled`
+	*   表示，`isTruthyLike` 为假说明该项已不被加载）；
+	* - 对 `group:xxx` 分组键递归处理其子插件。
+	*
+	* @param plugins 某层上下文的 plugins 配置对象
+	* @param ctx 该层对应的运行时上下文（用于查找 fork 记录）
+	*/
+	getGroup(plugins, ctx) {
+		const result = { ...plugins };
+		for (const key in plugins ?? {}) {
+			if (key.startsWith("$")) continue;
+			const value = plugins?.[key];
+			const name = (key.split(":", 1)[0] ?? "").replace(/^~/, "");
+			if (!this.loader.isTruthyLike(value?.["$if"])) {
+				delete result[key];
+				continue;
+			}
+			const fork = ctx.scope[Loader.kRecord]?.[key];
+			if (!fork) continue;
+			if (name === "group") result[key] = this.getGroup(value, fork.ctx);
+		}
+		return result;
+	}
+	/** 数据服务读取入口：返回去除敏感内部键后的整份应用配置。 */
+	async get() {
+		const result = { ...this.loader.config };
+		result.plugins = this.getGroup(result.plugins, this.loader.entry);
+		return result;
+	}
+	/**
+	* 保存全局设置：用前端提交的整份配置替换当前配置（保留原有的 plugins
+	* 部分），写回配置文件后执行全量重载（进程内重启全部插件）。
+	*
+	* @param config 前端提交的应用级配置（不含 plugins）
+	*/
+	async reloadApp(config) {
+		delete config["$paths"];
+		const plugins = this.loader.config.plugins;
+		this.loader.config = config;
+		Object.assign(this.loader.config, { plugins });
+		await this.loader.writeConfig();
+		this.loader.fullReload();
+	}
+	/**
+	* 根据路径标识查找对应的 fork 作用域。
+	*
+	* 前端用"分组路径"（如 `group:abc` 的 `abc`）标识每个上下文：空串代表
+	* 根作用域，否则在所有已注册插件的子作用域中按 fork.key 匹配。
+	*
+	* @param ident 分组路径（空串表示根）
+	* @returns 对应的 ForkScope，找不到时返回 undefined
+	*/
+	resolveFork(ident) {
+		if (!ident) return this.loader.entry.scope;
+		for (const main of this.ctx.registry.values()) for (const fork of main.children) if (fork.key === ident) return fork;
+	}
+	/**
+	* 在配置文件中按路径标识递归定位插件条目。
+	*
+	* @param ident 插件的路径标识（键去掉 `name:` 前缀后的部分）
+	* @param config 当前层级的 plugins 配置（递归时传入分组内部）
+	* @returns [所在配置对象, 完整键名] 二元组
+	* @throws 找不到时抛出 "plugin not found"
+	*/
+	resolveConfig(ident, config = this.loader.config.plugins) {
+		if (config) for (const key in config) {
+			const name = key.split(":", 1)[0] ?? "";
+			if (key.slice(name.length + 1) === ident) return [config, key];
+			if (name === "group" || name === "~group") try {
+				return this.resolveConfig(ident, config[key]);
+			} catch {}
+		}
+		throw new Error("plugin not found");
+	}
+	/**
+	* 更新插件的元数据键（`$` 开头的内部控制字段，如 `$label`、`$collapsed`）。
+	*
+	* config 中值为 null 的键表示删除；其余键覆盖写入并置于该插件配置的
+	* 开头位置。仅写盘（writeConfig(true) 触发静默刷新），不重载插件。
+	*
+	* @param ident 插件路径标识
+	* @param config 待合并的元数据键值对
+	*/
+	async meta(ident, config) {
+		const [parent, key] = this.resolveConfig(ident);
+		const target = parent[key];
+		for (const key of Object.keys(config)) {
+			delete target[key];
+			if (config[key] === null) delete config[key];
+		}
+		insertKey(target, config, Object.keys(target));
+		await this.loader.writeConfig(true);
+	}
+	/**
+	* （重新）加载插件：用提交的配置替换内存中的插件配置，先热重载再写盘。
+	*
+	* @param parent 所属分组的路径标识（空串为根）
+	* @param key 插件键名（形如 `name:ident`）
+	* @param config 新的插件配置
+	*/
+	async reload(parent, key, config) {
+		const scope = this.resolveFork(parent);
+		if (!scope) throw new Error("plugin not found");
+		await this.loader.reload(scope.ctx, key, config);
+		rename(scope.config, key, key, config);
+		await this.loader.writeConfig();
+	}
+	/**
+	* 停用插件：卸载运行时并把配置键改写为 `~` 前缀（保留配置以便再启用）。
+	*
+	* 传入 index 时（克隆配置场景）把停用键插入到指定位置而非原位重命名。
+	*
+	* @param parent 所属分组的路径标识
+	* @param key 插件键名
+	* @param config 停用时保留的插件配置
+	* @param index 可选的目标插入位置（在父配置的键序列中的序号）
+	*/
+	async unload(parent, key, config = {}, index) {
+		const scope = this.resolveFork(parent);
+		if (!scope) throw new Error("plugin not found");
+		this.loader.unload(scope.ctx, key);
+		if (index) {
+			const rest = Object.keys(scope.config).slice(index);
+			insertKey(scope.config, { [`~${key}`]: config }, rest);
+		} else rename(scope.config, key, `~${key}`, config);
+		await this.loader.writeConfig();
+	}
+	/**
+	* 移除插件：卸载运行时并从配置文件中彻底删除对应键（含 `~` 停用态）。
+	*
+	* @param parent 所属分组的路径标识
+	* @param key 插件键名
+	*/
+	async remove(parent, key) {
+		const scope = this.resolveFork(parent);
+		if (!scope) throw new Error("plugin not found");
+		this.loader.unload(scope.ctx, key);
+		const config = scope.config;
+		delete config[key];
+		delete config[`~${key}`];
+		await this.loader.writeConfig();
+	}
+	/**
+	* 拖拽移动插件：把插件从 source 分组搬到 target 分组的 index 位置。
+	*
+	* 分两步：
+	* 1. 迁移运行时 fork（改挂父作用域、迁移 disposables、修正原型链，
+	*    若注入的服务在两个分组中取值不同则重启该 fork）；
+	* 2. 迁移配置键（dropKey 摘出后 insertKey 插入目标位置）。
+	*
+	* @param source 源分组的路径标识（空串为根）
+	* @param key 被移动的插件键名
+	* @param target 目标分组的路径标识
+	* @param index 目标插入位置（目标分组键序列中的序号）
+	*/
+	async teleport(source, key, target, index) {
+		const parentS = this.resolveFork(source);
+		const parentT = this.resolveFork(target);
+		if (!parentS || !parentT) throw new Error("plugin not found");
+		const fork = parentS[Loader.kRecord]?.[key];
+		if (fork && parentS !== parentT) {
+			const sourceRecord = parentS[Loader.kRecord] ??= Object.create(null);
+			delete sourceRecord[key];
+			const targetRecord = parentT[Loader.kRecord] ??= Object.create(null);
+			targetRecord[key] = fork;
+			remove(parentS.disposables, fork.dispose);
+			parentT.disposables.push(fork.dispose);
+			fork.parent = parentT.ctx;
+			Object.setPrototypeOf(fork.ctx, parentT.ctx);
+			fork.ctx.emit("internal/fork", fork);
+			if (Object.keys(fork.runtime.inject).some((name) => Reflect.get(parentS, name) !== Reflect.get(parentT, name))) fork.restart();
+		}
+		const temp = dropKey(parentS.config, key);
+		const rest = Object.keys(parentT.config).slice(index);
+		insertKey(parentT.config, temp, rest);
+		await this.loader.writeConfig();
+	}
+};
+//#endregion
+//#region src/node/packages.ts
+/**
+* PackageProvider 的 Node 端实现：基于 LocalScanner 扫描本机
+* node_modules 中的插件包，并在扫描过程中顺带解析已加载插件的
+* 运行时信息写入共享 cache。
+*/
+const logger = new Logger("config");
+/**
+* 本机插件扫描器：在 LocalScanner 的基础上扩展 parsePackage，
+* 让"扫描到某个包"与"解析该插件的运行时信息"在同一次遍历中完成。
+*/
+var PackageScanner = class extends LocalScanner {
+	service;
+	constructor(service) {
+		super(service.ctx.baseDir);
+		this.service = service;
+	}
+	/** 单个包解析失败时仅记录警告，不中断整体扫描。 */
+	async onError(error, name) {
+		logger.warn("failed to resolve %c", name);
+		logger.warn(error);
+	}
+	/**
+	* 解析包元数据后，若该插件的入口模块已被 require 进内存，
+	* 则顺带解析其导出并写入服务缓存，供前端立即取用。
+	*/
+	async parsePackage(name) {
+		const result = await super.parsePackage(name);
+		try {
+			const entry = __require.resolve(name);
+			if (__require.cache[entry]) {
+				name = name.replace(/(koishi-|^@koishijs\/)plugin-/, "");
+				this.service.cache[name] = await this.service.parseExports(name);
+			}
+		} catch (error) {
+			this.onError(error, name);
+		}
+		return result;
+	}
+};
+/** Node 端包提供器：collect 委托给本机扫描器。 */
+var PackageProvider$1 = class extends PackageProvider {
+	scanner = new PackageScanner(this);
+	/**
+	* 扫描本机插件包并返回扫描结果。
+	*
+	* @param forced 为 true 时强制重新扫描（不走缓存）
+	*/
+	async collect(forced) {
+		await this.scanner.collect(forced);
+		return this.scanner.objects;
+	}
+};
+//#endregion
+//#region src/node/index.ts
+/**
+* config 插件的 Node 端入口。
+*
+* 前置检查 loader 的可写性（只有 koishi.yml / koishi.json 这类文件型
+* 配置才支持网页编辑），随后挂载三个数据服务（插件包元数据、服务状态、
+* 配置写入器），并把 client 目录注册为控制台前端入口。
+*/
+const name = "config";
+const inject = ["console"];
+const Config = Schema.object({});
+function apply(ctx) {
+	if (!ctx.loader?.writable) return ctx.logger("app").warn("@koishi-ce/plugin-config is only available for json/yaml config file");
+	ctx.plugin(PackageProvider$1);
+	ctx.plugin(ServiceProvider);
+	ctx.plugin(ConfigWriter);
+	ctx.console.addEntry({
+		dev: resolve(__dirname, "../../client/index.ts"),
+		prod: resolve(__dirname, "../../dist")
+	});
+}
+//#endregion
+export { Config, ConfigWriter, PackageProvider, ServiceProvider, apply, inject, name };

package/package.json

@@ -0,0 +1,78 @@
+{
+    "name": "@koishi-ce/plugin-config",
+    "description": "Manage your bots and plugins with console",
+    "version": "1.0.0",
+    "type": "module",
+    "main": "lib/index.mjs",
+    "types": "lib/index.d.ts",
+    "exports": {
+        ".": {
+            "source": "./src/index.ts",
+            "types": "./lib/index.d.ts",
+            "import": "./lib/index.mjs",
+            "default": "./lib/index.mjs"
+        },
+        "./shared": {
+            "import": "./lib/shared/index.mjs",
+            "default": "./lib/shared/index.mjs"
+        },
+        "./src/*": "./src/*",
+        "./package.json": "./package.json"
+    },
+    "files": [
+        "lib",
+        "dist",
+        "src"
+    ],
+    "contributors": [
+        "Shigma <shigma10826@gmail.com>",
+        "Oppenheymu <oppenheymu@gmail.com>"
+    ],
+    "license": "AGPL-3.0",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Koishi-CE/koishi.git",
+        "directory": "plugins/webui/config"
+    },
+    "bugs": {
+        "url": "https://github.com/Koishi-CE/koishi/issues"
+    },
+    "homepage": "https://koishi.chat/plugins/console/config.html",
+    "keywords": [
+        "bot",
+        "chatbot",
+        "koishi",
+        "plugin",
+        "config",
+        "manager",
+        "server"
+    ],
+    "koishi": {
+        "public": [
+            "dist"
+        ],
+        "description": {
+            "en": "Configure your plugins with console",
+            "zh": "使用控制台查看、配置你的插件"
+        },
+        "service": {
+            "required": [
+                "console"
+            ]
+        }
+    },
+    "peerDependencies": {
+        "@koishijs/loader": "^4.6.11",
+        "@koishijs/plugin-console": "^5.30.11",
+        "koishi": "^4.18.11"
+    },
+    "devDependencies": {
+        "@koishi-ce/client": "^1.0.0",
+        "@koishi-ce/plugin-hmr": "^1.0.0"
+    },
+    "dependencies": {
+        "@koishi-ce/console": "^1.0.0",
+        "@koishi-ce/loader": "^1.0.0",
+        "@koishi-ce/registry": "^1.0.0"
+    }
+}

package/src/browser/index.ts

@@ -0,0 +1,36 @@
+/**
+ * config 插件的浏览器端入口。
+ *
+ * 与 node 入口共用 shared 的三个数据服务，差别在于：
+ * 1. 额外注入 loader 服务；
+ * 2. 前端资源不走 addEntry 的 dev/prod 约定，而是显式给出资源 URL——
+ *    设置了 KOISHI_BASE 环境变量时从远端加载打包产物，否则回退到
+ *    client 源码（供开发调试用）。
+ */
+import { type Context, Schema } from "@koishi-ce/koishi";
+import { ConfigWriter, ServiceProvider } from "../shared/index.ts";
+import { PackageProvider } from "./packages.ts";
+
+export * from "../shared/index.ts";
+
+export const name = "config";
+export const inject = ["console", "loader"];
+
+export type Config = Record<never, never>;
+
+export const Config: Schema<Config> = Schema.object({});
+
+export function apply(ctx: Context) {
+	ctx.plugin(PackageProvider);
+	ctx.plugin(ConfigWriter);
+	ctx.plugin(ServiceProvider);
+
+	ctx.console.addEntry(
+		process.env["KOISHI_BASE"]
+			? [
+					`${process.env["KOISHI_BASE"]}/dist/index.js`,
+					`${process.env["KOISHI_BASE"]}/dist/style.css`,
+				]
+			: [import.meta.url.replace(/\/src\/[^/]+\/[^/]+$/, "/client/index.ts")],
+	);
+}

package/src/browser/packages.ts

@@ -0,0 +1,7 @@
+import * as shared from "../shared/index.ts";
+
+export class PackageProvider extends shared.PackageProvider {
+	async collect(_forced: boolean) {
+		return this.ctx.loader.market.objects;
+	}
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+// placeholder file, do not modify
+export * from "./node/index.ts";

package/src/node/index.ts

@@ -0,0 +1,42 @@
+/**
+ * config 插件的 Node 端入口。
+ *
+ * 前置检查 loader 的可写性（只有 koishi.yml / koishi.json 这类文件型
+ * 配置才支持网页编辑），随后挂载三个数据服务（插件包元数据、服务状态、
+ * 配置写入器），并把 client 目录注册为控制台前端入口。
+ */
+
+import { resolve } from "node:path";
+import { type Context, Schema } from "@koishi-ce/koishi";
+import { ConfigWriter, ServiceProvider } from "../shared/index.ts";
+import { PackageProvider } from "./packages.ts";
+
+export * from "../shared/index.ts";
+
+export const name = "config";
+export const inject = ["console"];
+
+export type Config = Record<never, never>;
+
+export const Config: Schema<Config> = Schema.object({});
+
+export function apply(ctx: Context) {
+	// 仅文件型配置(可写)支持本插件,其余环境(如环境变量驱动)直接跳过
+	if (!ctx.loader?.writable) {
+		return ctx
+			.logger("app")
+			.warn(
+				"@koishi-ce/plugin-config is only available for json/yaml config file",
+			);
+	}
+
+	ctx.plugin(PackageProvider);
+	ctx.plugin(ServiceProvider);
+	ctx.plugin(ConfigWriter);
+
+	// 注册控制台前端资源:dev 模式直接指向 client 源码,prod 指向打包产物
+	ctx.console.addEntry({
+		dev: resolve(__dirname, "../../client/index.ts"),
+		prod: resolve(__dirname, "../../dist"),
+	});
+}