mioku 1.1.1 → 1.2.0

package/dist/cli/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { clearCommandCache, commandExists, resolveCommand, runCommandInherit, version } from "../exec-vSS4BZ4z.js";
+import { clearCommandCache, commandExists, resolveCommand, runCommandInherit, version } from "../exec-JBR-IZk0.js";
 import fs, { readFileSync } from "node:fs";
 import path from "node:path";
 import mri from "mri";
@@ -52,6 +52,10 @@ async function searchMiokuPackages(prefix) {
 	}
 	return hits.sort((a, b) => a.name.localeCompare(b.name));
 }
+/** 取官方注册表中某类别需要隐藏的包短名 */
+function hiddenShortNames(registry, type) {
+	return new Set(registry?.hidden?.[type] ?? []);
+}
 async function fetchOfficialRegistry() {
 	try {
 		const res = await fetch(OFFICIAL_REGISTRY_URL, { headers: {
@@ -126,6 +130,15 @@ async function multiSelect(message, items, initial = [], options = {}) {
 	});
 	return result.map((item) => typeof item === "string" ? item : item.value);
 }
+/** 单选框，取消时抛出（调用方负责兜底） */
+async function selectOne(message, items) {
+	const result = await consola.prompt(message, {
+		type: "select",
+		options: items,
+		cancel: "reject"
+	});
+	return result;
+}
 function runAdapterCli(name, cwd) {
 	const isWin = process.platform === "win32";
 	const exts = isWin ? [
@@ -277,11 +290,20 @@ async function getInstalledPackages(cwd) {
 			...pkg.dependencies,
 			...pkg.devDependencies
 		};
-		return Object.keys(deps).filter((k) => k.startsWith("mioku-"));
+		return Object.keys(deps).filter((k) => k === "mioku" || k.startsWith("mioku-"));
 	} catch {
 		return [];
 	}
 }
+/** 读取已安装包的版本，未安装返回 null */
+function installedVersionOf(cwd, pkgName) {
+	try {
+		const pkg = JSON.parse(readFileSync(path.join(cwd, "node_modules", pkgName, "package.json"), "utf-8"));
+		return String(pkg.version || "") || null;
+	} catch {
+		return null;
+	}
+}
 function withRoot(p) {
 	return path.resolve(process.cwd(), p);
 }
@@ -324,11 +346,14 @@ function buildHelpInfo(version$1) {
   用法: mioku <命令> [选项]
 
   命令:
-    install plugin <名称>   安装插件，自动补全 mioku-plugin- 前缀
-    install service <名称>  安装服务，自动补全 mioku-service- 前缀
+    install [类型] [名称]   安装包；不带参数时进入交互选择
+                            install              - 选择安装 mioku 框架 / 插件 / 服务 / 适配器
+                            install plugin <名称>  安装插件，自动补全 mioku-plugin- 前缀
+                            install service <名称> 安装服务，自动补全 mioku-service- 前缀
+                            install adapter <名称> 安装适配器并运行配置向导
     update [包名|self|all]   更新插件或服务
-                            update          - 检查可用更新
-                            update all      - 更新所有 mioku- 包
+                            update          - 检查可用更新（含 mioku 框架）并选择更新
+                            update all      - 更新所有 mioku 包（含框架）
                             update self     - 更新 mioku 框架
                             update xxx      - 更新指定包
 
@@ -364,118 +389,39 @@ async function input(message, options) {
 }
 
 //#endregion
-//#region src/cli/install.ts
-async function installCommand(cmdArgs, helpInfo) {
-	ensurePackageManager();
-	const cwd = process.cwd();
-	const [type, name] = cmdArgs;
-	if (!type || !name) {
-		consola.error("请指定类型和名称: mioku install plugin <名称> 或 mioku install service <名称>");
-		console.log(helpInfo);
-		return 1;
-	}
-	if (type !== "plugin" && type !== "service") {
-		consola.error(`无效的类型 "${type}"，请使用 plugin 或 service`);
-		console.log(helpInfo);
-		return 1;
-	}
-	const prefix = type === "plugin" ? PLUGIN_PREFIX : SERVICE_PREFIX;
-	const normalized = `${prefix}${name}`;
-	if (type === "plugin") {
-		const proceed = await warnIfPrivatePlugin(normalized);
-		if (!proceed) {
-			consola.info("已取消安装");
-			return 1;
-		}
-	}
-	try {
-		execAdd([normalized], cwd);
-		consola.success(`已安装 ${normalized}`);
-		if (type === "plugin") {
-			const shortName = normalized.slice(PLUGIN_PREFIX.length);
-			if (appendToMiokuPlugins(cwd, normalized)) consola.success(`已在 mioku.plugins 中启用 ${shortName}`);
-			else consola.info(`${shortName} 已在 mioku.plugins 中，跳过`);
-		}
-		return 0;
-	} catch {
-		consola.error(`安装失败: ${normalized}`);
-		return 1;
-	}
-}
-async function warnIfPrivatePlugin(pkgName) {
-	const keywords = await fetchNpmKeywords(pkgName);
-	if (keywords === null) return true;
-	if (keywords.includes("mioku")) return true;
-	consola.warn(`${pkgName} 看起来是私有插件"`);
-	consola.warn("该插件未上架插件市场，可能存在风险");
-	return confirm("仍要继续安装吗？", { initial: false });
-}
-
-//#endregion
-//#region src/cli/update.ts
-async function updatePackages(packages, cwd) {
-	if (packages.length === 0) {
-		consola.info("未找到 mioku- 相关依赖");
-		return;
-	}
-	console.log(`执行: bun update ${packages.join(" ")} --latest`);
-	run("bun", [
-		"update",
-		...packages,
-		"--latest"
-	], { cwd });
-}
-async function updateByPrefix(prefix, cwd, name) {
-	if (name) {
-		const normalized = name.startsWith(prefix) ? name : `${prefix}${name}`;
-		console.log(`执行: bun update ${normalized} --latest`);
-		run("bun", [
-			"update",
-			normalized,
-			"--latest"
-		], { cwd });
-		return;
-	}
-	const packages = (await getInstalledPackages(cwd)).filter((p) => p.startsWith(prefix));
-	if (packages.length === 0) {
-		consola.info(`未找到 ${prefix}* 相关依赖`);
-		return;
-	}
-	await updatePackages(packages, cwd);
-}
-async function updateCommand(cmdArgs) {
-	ensurePackageManager();
-	const cwd = process.cwd();
-	const [target, name] = cmdArgs;
-	if (!target || target === "check") {
-		run("bun", ["update", "-i"], { cwd });
-		return 0;
-	}
-	if (target === "all") {
-		await updatePackages(await getInstalledPackages(cwd), cwd);
-		return 0;
-	}
-	if (target === "self") {
-		console.log("执行: bun update mioku --latest");
-		run("bun", [
-			"update",
-			"mioku",
-			"--latest"
-		], { cwd });
-		return 0;
-	}
-	if (target === "plugin" || target === "service") {
-		const prefix = target === "plugin" ? PLUGIN_PREFIX : SERVICE_PREFIX;
-		await updateByPrefix(prefix, cwd, name);
-		return 0;
+//#region src/cli/market-select.ts
+const PACKAGE_TYPE_PREFIX = {
+	plugin: PLUGIN_PREFIX,
+	service: SERVICE_PREFIX,
+	adapter: ADAPTER_PREFIX
+};
+/** 从 npm 拉取市场包并让用户多选；官方注册表 hidden 名单内的包不展示 */
+async function pickMarketPackages(type, message, options = {}) {
+	const prefix = PACKAGE_TYPE_PREFIX[type];
+	console.log(`\n正在从 npm 拉取 ${prefix}* 包...`);
+	const [hits, registry] = await Promise.all([searchMiokuPackages(prefix), fetchOfficialRegistry()]);
+	if (hits.length === 0) {
+		consola.warn(`未在 npm 上找到任何 ${prefix}* 包`);
+		return [];
 	}
-	console.log(`执行: bun update ${target} --latest`);
-	run("bun", [
-		"update",
-		target,
-		"--latest"
-	], { cwd });
-	return 0;
+	const official = new Set();
+	for (const group of [
+		registry?.plugins,
+		registry?.services,
+		registry?.adapters
+	]) for (const entry of Object.values(group ?? {})) if (entry?.npm) official.add(entry.npm);
+	const hidden = hiddenShortNames(registry, type);
+	const excludeSet = new Set(options.exclude ?? []);
+	const items = hits.filter((hit) => !excludeSet.has(hit.name) && !hidden.has(shortNameOfPackage(hit.name))).map((hit) => {
+		const shortName = shortNameOfPackage(hit.name);
+		const desc = hit.description || "暂无介绍";
+		const badge = official.has(hit.name) ? "官方" : "社区";
+		return {
+			label: `${shortName}  (${badge} · ${desc})`,
+			value: hit.name
+		};
+	});
+	return multiSelect(message, items, [], { required: false });
 }
 
 //#endregion
@@ -513,30 +459,8 @@ async function createNewProject(name, fileTree) {
 	run("bun", ["i"], { cwd: projectPath });
 	return projectPath;
 }
-async function selectPackages(message, prefix, initial = [], options = {}) {
-	console.log(`\n正在从 npm 拉取 ${prefix}* 包...`);
-	const [hits, registry] = await Promise.all([searchMiokuPackages(prefix), fetchOfficialRegistry()]);
-	if (hits.length === 0) {
-		consola.warn(`未在 npm 上找到任何 ${prefix}* 包`);
-		return [];
-	}
-	const official = new Set();
-	for (const group of [
-		registry?.plugins,
-		registry?.services,
-		registry?.adapters
-	]) for (const entry of Object.values(group ?? {})) if (entry?.npm) official.add(entry.npm);
-	const excludeSet = new Set(options.exclude ?? []);
-	const items = hits.filter((hit) => !excludeSet.has(hit.name)).map((hit) => {
-		const shortName = shortNameOfPackage(hit.name);
-		const desc = hit.description || "暂无介绍";
-		const badge = official.has(hit.name) ? "官方" : "社区";
-		return {
-			label: `${shortName}  (${badge} · ${desc})`,
-			value: hit.name
-		};
-	});
-	return multiSelect(message, items, initial, { required: false });
+async function selectPackages(message, type, options = {}) {
+	return pickMarketPackages(type, message, options);
 }
 async function scaffoldCommand() {
 	const name = await input("请输入项目名称", {
@@ -551,7 +475,7 @@ async function scaffoldCommand() {
 	});
 	ensurePackageManager();
 	const ownersList = [...String(owners).split(",").map((o) => o.trim()).filter(Boolean), STDIN_OWNER];
-	const adapterNames = await selectPackages("选择要安装的适配器（上下键选择，空格勾选，回车确认）", ADAPTER_PREFIX, [], { exclude: SYSTEM_ADAPTERS });
+	const adapterNames = await selectPackages("选择要安装的适配器（上下键选择，空格勾选，回车确认）", "adapter", { exclude: SYSTEM_ADAPTERS });
 	const allAdapterNames = [...SYSTEM_ADAPTERS, ...adapterNames];
 	if (adapterNames.length === 0) consola.info("未选择其他适配器，仅启用标准输入");
 	const pkgJsonObj = {
@@ -613,7 +537,7 @@ async function scaffoldCommand() {
 		runAdapterCli(adapterName, projectPath);
 	}
 	consola.info(`已自动安装并启用系统适配器: ${SYSTEM_ADAPTERS.map(shortNameOfPackage).join(", ")}`);
-	const pluginNames = await selectPackages("选择要安装的插件（上下键选择，空格勾选，回车确认）", PLUGIN_PREFIX, [], { exclude: SYSTEM_PLUGINS });
+	const pluginNames = await selectPackages("选择要安装的插件（上下键选择，空格勾选，回车确认）", "plugin", { exclude: SYSTEM_PLUGINS });
 	consola.info(`系统插件将自动安装: ${SYSTEM_PLUGINS.map(shortNameOfPackage).join(", ")}`);
 	const enabledPlugins = [
 		"demo",
@@ -644,6 +568,247 @@ async function scaffoldCommand() {
 	return 0;
 }
 
+//#endregion
+//#region src/cli/install.ts
+const INSTALL_TARGETS = [
+	{
+		label: "mioku 框架 —— 创建新的机器人项目（同 npx mioku）",
+		value: "mioku"
+	},
+	{
+		label: "插件 (plugin) —— 安装到当前项目",
+		value: "plugin"
+	},
+	{
+		label: "服务 (service) —— 安装到当前项目",
+		value: "service"
+	},
+	{
+		label: "适配器 (adapter) —— 安装到当前项目并运行配置向导",
+		value: "adapter"
+	}
+];
+async function installCommand(cmdArgs, helpInfo) {
+	const [type, name] = cmdArgs;
+	if (!type) return installInteractive();
+	if (type === "plugin" || type === "service" || type === "adapter") {
+		if (!name) return installInteractive(type);
+		ensurePackageManager();
+		return installNamed(type, name);
+	}
+	consola.error(`无效的类型 "${type}"，请使用 plugin、service 或 adapter`);
+	console.log(helpInfo);
+	return 1;
+}
+/** 不带参数：选择安装 mioku 框架或插件/服务/适配器 */
+async function installInteractive(type) {
+	let target;
+	if (type) target = type;
+	else try {
+		target = await selectOne("要安装什么？（上下键选择，回车确认）", INSTALL_TARGETS);
+	} catch {
+		consola.info("已取消");
+		return 0;
+	}
+	if (target === "mioku") return scaffoldCommand();
+	ensurePackageManager();
+	const cwd = process.cwd();
+	if (!fs.existsSync(path.join(cwd, "package.json"))) {
+		consola.error("当前目录不是 mioku 项目（未找到 package.json），请先运行 mioku 创建项目或切换到项目目录");
+		return 1;
+	}
+	const packages = await pickMarketPackages(target, "选择要安装的包（上下键选择，空格勾选，回车确认）");
+	if (packages.length === 0) {
+		consola.info("未选择任何包，已取消安装");
+		return 0;
+	}
+	const ok = await confirm(`确认安装以下 ${packages.length} 个包？\n${packages.map((p) => `  - ${p}`).join("\n")}`);
+	if (!ok) {
+		consola.info("已取消安装");
+		return 1;
+	}
+	return installPackages(target, packages, cwd);
+}
+/** 带类型和名称：直接安装指定包 */
+async function installNamed(type, name) {
+	const cwd = process.cwd();
+	const prefix = type === "plugin" ? PLUGIN_PREFIX : type === "service" ? SERVICE_PREFIX : ADAPTER_PREFIX;
+	const normalized = name.startsWith(prefix) ? name : `${prefix}${name}`;
+	if (type === "plugin") {
+		const proceed = await warnIfPrivatePlugin(normalized);
+		if (!proceed) {
+			consola.info("已取消安装");
+			return 1;
+		}
+		const services = await resolveRequiredServices([normalized]);
+		if (services.length > 0) {
+			consola.info(`将一并安装插件声明的服务: ${services.map(shortNameOfPackage).join(", ")}`);
+			return installPackages("plugin", [normalized, ...services], cwd);
+		}
+		return installPackages("plugin", [normalized], cwd);
+	}
+	return installPackages(type, [normalized], cwd);
+}
+async function installPackages(type, packages, cwd) {
+	try {
+		execAdd(packages, cwd);
+		consola.success(`已安装 ${packages.join(" ")}`);
+	} catch {
+		consola.error(`安装失败: ${packages.join(" ")}`);
+		return 1;
+	}
+	if (type === "plugin") for (const pkg of packages) {
+		if (!pkg.startsWith(PLUGIN_PREFIX)) continue;
+		if (appendToMiokuPlugins(cwd, pkg)) consola.success(`已在 mioku.plugins 中启用 ${shortNameOfPackage(pkg)}`);
+		else consola.info(`${shortNameOfPackage(pkg)} 已在 mioku.plugins 中，跳过`);
+	}
+	if (type === "adapter") for (const pkg of packages) {
+		const adapterName = shortNameOfPackage(pkg);
+		consola.info(`正在运行 ${pkg} 配置向导...`);
+		runAdapterCli(adapterName, cwd);
+	}
+	return 0;
+}
+async function warnIfPrivatePlugin(pkgName) {
+	const keywords = await fetchNpmKeywords(pkgName);
+	if (keywords === null) return true;
+	if (keywords.includes("mioku")) return true;
+	consola.warn(`${pkgName} 看起来是私有插件"`);
+	consola.warn("该插件未上架插件市场，可能存在风险");
+	return confirm("仍要继续安装吗？", { initial: false });
+}
+
+//#endregion
+//#region src/cli/update.ts
+async function updatePackages(packages, cwd) {
+	if (packages.length === 0) {
+		consola.info("未找到 mioku 相关依赖");
+		return;
+	}
+	console.log(`执行: bun update ${packages.join(" ")} --latest`);
+	run("bun", [
+		"update",
+		...packages,
+		"--latest"
+	], { cwd });
+}
+async function updateByPrefix(prefix, cwd, name) {
+	if (name) {
+		const normalized = name.startsWith(prefix) ? name : `${prefix}${name}`;
+		console.log(`执行: bun update ${normalized} --latest`);
+		run("bun", [
+			"update",
+			normalized,
+			"--latest"
+		], { cwd });
+		return;
+	}
+	const packages = (await getInstalledPackages(cwd)).filter((p) => p.startsWith(prefix));
+	if (packages.length === 0) {
+		consola.info(`未找到 ${prefix}* 相关依赖`);
+		return;
+	}
+	await updatePackages(packages, cwd);
+}
+/** latest 是否比 current 更新（按数字段比较，避免把已装的新版本倒退回去） */
+function isNewerVersion(latest, current) {
+	const parse = (v) => {
+		const [core, pre = ""] = v.split("-");
+		return {
+			nums: core.split(".").map((n) => Number(n) || 0),
+			pre
+		};
+	};
+	const a = parse(latest);
+	const b = parse(current);
+	for (let i = 0; i < 3; i++) {
+		const diff = (a.nums[i] ?? 0) - (b.nums[i] ?? 0);
+		if (diff !== 0) return diff > 0;
+	}
+	if (!a.pre && b.pre) return true;
+	if (a.pre && !b.pre) return false;
+	return a.pre > b.pre;
+}
+/** 对比 npm 上的最新版本，找出所有可更新的 mioku 包（含框架本身） */
+async function collectOutdated(cwd) {
+	const packages = await getInstalledPackages(cwd);
+	const checked = await Promise.all(packages.map(async (name) => ({
+		name,
+		current: installedVersionOf(cwd, name),
+		meta: await fetchNpmPackageMeta(name)
+	})));
+	const outdated = [];
+	for (const { name, current, meta } of checked) {
+		if (!current) continue;
+		const latest = meta?.version;
+		if (!latest || !isNewerVersion(latest, current)) continue;
+		outdated.push({
+			name,
+			current,
+			latest
+		});
+	}
+	return outdated.sort((a, b) => a.name.localeCompare(b.name));
+}
+/** 检查更新并列出选择框（含 mioku 框架本身），确认后更新选中项 */
+async function updateCheckFlow(cwd) {
+	consola.info("正在检查 mioku 包更新...");
+	const outdated = await collectOutdated(cwd);
+	if (outdated.length === 0) {
+		consola.success("所有 mioku 包均已是最新版本");
+		return 0;
+	}
+	consola.info(`发现 ${outdated.length} 个可更新包`);
+	const items = outdated.map((o) => ({
+		label: `${o.name}  ${o.current} → ${o.latest}`,
+		value: o.name
+	}));
+	let selected;
+	try {
+		selected = await multiSelect("选择要更新的包（空格勾选，回车确认）", items, []);
+	} catch {
+		consola.info("已取消");
+		return 0;
+	}
+	if (selected.length === 0) {
+		consola.info("未选择任何包");
+		return 0;
+	}
+	await updatePackages(selected, cwd);
+	return 0;
+}
+async function updateCommand(cmdArgs) {
+	ensurePackageManager();
+	const cwd = process.cwd();
+	const [target, name] = cmdArgs;
+	if (!target || target === "check") return updateCheckFlow(cwd);
+	if (target === "all") {
+		await updatePackages(await getInstalledPackages(cwd), cwd);
+		return 0;
+	}
+	if (target === "self") {
+		console.log("执行: bun update mioku --latest");
+		run("bun", [
+			"update",
+			"mioku",
+			"--latest"
+		], { cwd });
+		return 0;
+	}
+	if (target === "plugin" || target === "service") {
+		const prefix = target === "plugin" ? PLUGIN_PREFIX : SERVICE_PREFIX;
+		await updateByPrefix(prefix, cwd, name);
+		return 0;
+	}
+	console.log(`执行: bun update ${target} --latest`);
+	run("bun", [
+		"update",
+		target,
+		"--latest"
+	], { cwd });
+	return 0;
+}
+
 //#endregion
 //#region src/cli/index.ts
 const args = process.argv.slice(2);