@koishi-ce/plugin-market 1.0.0

package/src/node/index.ts

@@ -0,0 +1,229 @@
+import { resolve } from "node:path";
+import { type Context, type Dict, pick, Schema } from "@koishi-ce/koishi";
+import type { DependencyMetaKey, RemotePackage } from "@koishi-ce/registry";
+import { gt } from "semver";
+import { DependencyProvider, RegistryProvider } from "./deps.ts";
+import Installer from "./installer.ts";
+import messageZhCN from "./locales/message.zh-CN.yml";
+import schemaZhCN from "./locales/schema.zh-CN.yml";
+import MarketProvider from "./market.ts";
+
+export * from "../shared/index.ts";
+
+export { DependencyProvider, Installer, RegistryProvider };
+
+declare module "@koishi-ce/koishi" {
+	interface Context {
+		installer: Installer;
+	}
+}
+
+declare module "@koishi-ce/console" {
+	namespace Console {
+		interface Services {
+			dependencies: DependencyProvider;
+			registry: RegistryProvider;
+		}
+	}
+
+	interface Events {
+		"market/install"(deps: Dict<string>, forced?: boolean): Promise<number>;
+		"market/registry"(
+			names: string[],
+		): Promise<Dict<Dict<Pick<RemotePackage, DependencyMetaKey>>>>;
+	}
+}
+
+export const name = "market";
+export const inject = ["http"];
+
+export const usage = `
+如果插件市场页面提示「无法连接到插件市场」，则可以选择一个 Koishi 社区提供的镜像地址，填入下方对应的配置项中。
+
+## 插件市场（填入 search.endpoint）
+
+- Koishi（全球）：https://registry.koishi.chat/index.json
+- [t4wefan](https://k.ilharp.cc/2611)（大陆）：https://registry.koishi.t4wefan.pub/index.json
+- [Lipraty](https://k.ilharp.cc/3530)（大陆）：https://koi.nyan.zone/registry/index.json
+- [itzdrli](https://k.ilharp.cc/9975)（全球）：https://kp.itzdrli.cc
+- [Q78KG](https://k.ilharp.cc/10042)（全球）：https://koishi-registry.yumetsuki.moe/index.json
+
+要浏览更多社区镜像，请访问 [Koishi 论坛上的镜像一览](https://k.ilharp.cc/4000)。`;
+
+// ## 软件源（填入 npmRegistryServer）
+
+// - 淘宝（大陆）：https://registry.npmmirror.com
+// - 腾讯（大陆）：https://mirrors.cloud.tencent.com/npm
+// - npm（全球）：https://registry.npmjs.org
+// - yarn（全球）：https://registry.yarnpkg.com
+
+export interface Config {
+	registry?: Installer.Config;
+	search?: MarketProvider.Config;
+}
+
+export const Config: Schema<Config> = Schema.object({
+	registry: Installer.Config,
+	search: MarketProvider.Config,
+}).i18n({
+	"zh-CN": schemaZhCN,
+});
+
+export function apply(ctx: Context, config: Config) {
+	if (!ctx.loader?.writable) {
+		return ctx
+			.logger("app")
+			.warn(
+				"@koishijs/plugin-market is only available for json/yaml config file",
+			);
+	}
+
+	ctx.plugin(Installer, config.registry);
+
+	ctx.inject(["installer"], (ctx) => {
+		ctx.i18n.define("zh-CN", messageZhCN);
+
+		ctx
+			.command("plugin.install <name>", { authority: 4 })
+			.alias(".i")
+			.action(async ({ session }, name) => {
+				if (!session) return;
+				if (!name) return session.text(".expect-name");
+
+				// check local dependencies
+				const names = ctx.installer.resolveName(name);
+				const deps = await ctx.installer.getDeps();
+				if (names.find((name) => deps[name]))
+					return session.text(".already-installed");
+
+				// find proper version
+				const result = await ctx.installer.findVersion(names);
+				if (!result) return session.text(".not-found");
+
+				// set restart message
+				ctx.loader.envData.message = {
+					...pick(session, ["sid", "channelId", "guildId", "isDirect"]),
+					content: session.text(".success"),
+				};
+				await ctx.installer.install(result);
+				ctx.loader.envData.message = null;
+				return session.text(".success");
+			});
+
+		ctx
+			.command("plugin.uninstall <name>", { authority: 4 })
+			.alias(".r")
+			.action(async ({ session }, name) => {
+				if (!session) return;
+				if (!name) return session.text(".expect-name");
+
+				// check local dependencies
+				const names = ctx.installer.resolveName(name);
+				const deps = await ctx.installer.getDeps();
+				const installed = names.find((name) => deps[name]);
+				if (!installed) return session.text(".not-installed");
+
+				await ctx.installer.install({ [installed]: null });
+				return session.text(".success");
+			});
+
+		ctx
+			.command("plugin.upgrade [name...]", { authority: 4 })
+			.alias(".update", ".up")
+			.option("self", "-s, --koishi")
+			.action(async ({ session, options }, ...names) => {
+				if (!session) return;
+
+				async function getPackages(names: string[]) {
+					if (!names.length) return Object.keys(deps);
+					const resolved = names
+						.map((name) => {
+							const names = ctx.installer.resolveName(name);
+							return names.find((name) => deps[name]);
+						})
+						.filter((name): name is string => name !== undefined);
+					if (options?.self) resolved.push("koishi");
+					return resolved;
+				}
+
+				// refresh dependencies
+				ctx.installer.refresh(true);
+				const deps = await ctx.installer.getDeps();
+				names = (
+					await getPackages(names.filter((name): name is string => !!name))
+				).filter((name) => {
+					const { latest, resolved, invalid } = deps[name] ?? {};
+					if (latest === undefined || resolved === undefined) return false;
+					try {
+						return !invalid && gt(latest, resolved);
+					} catch {
+						return false;
+					}
+				});
+				if (!names.length) return session.text(".all-updated");
+
+				const output = names.map((name) => {
+					const { latest, resolved } = deps[name] ?? {};
+					return `${name}: ${resolved} -> ${latest}`;
+				});
+				output.unshift(session.text(".available"));
+				output.push(session.text(".prompt"));
+				await session.send(output.join("\n"));
+				const result = await session.prompt();
+				const answer = result?.trim();
+				if (answer !== "Y" && answer !== "y") {
+					return session.text(".cancelled");
+				}
+
+				ctx.loader.envData.message = {
+					...pick(session, ["sid", "channelId", "guildId", "isDirect"]),
+					content: session.text(".success"),
+				};
+				await ctx.installer.install(
+					names.reduce<Dict<string | null>>((result, name) => {
+						const latest = deps[name]?.latest;
+						if (latest !== undefined) result[name] = latest;
+						return result;
+					}, {}),
+				);
+				ctx.loader.envData.message = null;
+				return session.text(".success");
+			});
+	});
+
+	ctx.inject(["console", "installer"], (ctx) => {
+		ctx.plugin(DependencyProvider);
+		ctx.plugin(RegistryProvider);
+		ctx.plugin(MarketProvider, config.search);
+
+		ctx.console.addEntry({
+			dev: resolve(__dirname, "../../client/index.ts"),
+			prod: resolve(__dirname, "../../dist"),
+		});
+
+		ctx.console.addListener(
+			"market/install",
+			async (deps, forced) => {
+				const code = await ctx.installer.install(deps, forced);
+				ctx.get("console")?.refresh("dependencies");
+				ctx.get("console")?.refresh("registry");
+				ctx.get("console")?.refresh("packages");
+				return code;
+			},
+			{ authority: 4 },
+		);
+
+		ctx.console.addListener(
+			"market/registry",
+			async (names) => {
+				const meta = await Promise.all(
+					names.map((name) => ctx.installer.getPackage(name)),
+				);
+				return Object.fromEntries(
+					meta.map((meta, index) => [names[index], meta]),
+				);
+			},
+			{ authority: 4 },
+		);
+	});
+}

package/src/node/installer.ts

@@ -0,0 +1,388 @@
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { resolve } from "node:path";
+import type {} from "@koishi-ce/console";
+import {
+	type Context,
+	type Dict,
+	defineProperty,
+	type HTTP,
+	Logger,
+	pick,
+	Schema,
+	Service,
+	Time,
+	valueMap,
+} from "@koishi-ce/koishi";
+import type {} from "@koishi-ce/loader";
+import type {} from "@koishi-ce/plugin-market";
+import Scanner, {
+	type DependencyMetaKey,
+	type PackageJson,
+	type Registry,
+	type RemotePackage,
+} from "@koishi-ce/registry";
+import spawn from "execa";
+import getRegistry from "get-registry";
+import pMap from "p-map";
+import { compare, satisfies, valid } from "semver";
+
+const logger = new Logger("market");
+
+// 经 createRequire 加载 CJS 包并就地断言签名：不走 ESM 导入互操作，
+// 规避多包合并类型检查（大一统 tsconfig）下 export = 交织失效问题
+const whichPMRuns = createRequire(import.meta.url)("which-pm-runs") as () =>
+	| undefined
+	| { name: string; version: string };
+
+export interface Dependency {
+	/**
+	 * requested semver range
+	 * @example `^1.2.3` -> `1.2.3`
+	 */
+	request: string;
+	/**
+	 * installed package version
+	 * @example `1.2.5`
+	 */
+	resolved?: string | undefined;
+	/** whether it is a workspace package */
+	workspace?: boolean | undefined;
+	/** valid (unsupported) syntax */
+	invalid?: boolean | undefined;
+	/** latest version */
+	latest?: string | undefined;
+}
+
+export interface YarnLog {
+	type: "warning" | "info" | "error" | string;
+	name: number | null;
+	displayName: string;
+	indent?: string;
+	data: string;
+}
+
+const levelMap = {
+	info: "info",
+	warning: "debug",
+	error: "warn",
+} as const;
+
+export interface LocalPackage extends PackageJson {
+	private?: boolean;
+	$workspace?: boolean;
+	/** loadManifest 归一化保证 dependencies 必有 */
+	dependencies: Record<string, string>;
+}
+
+export function loadManifest(name: string) {
+	const filename = require.resolve(`${name}/package.json`);
+	const meta: LocalPackage = JSON.parse(readFileSync(filename, "utf8"));
+	meta.dependencies ||= {};
+	defineProperty(meta, "$workspace", !filename.includes("node_modules"));
+	return meta;
+}
+
+function getVersions(versions: RemotePackage[]) {
+	return Object.fromEntries(
+		versions
+			.map(
+				(item) =>
+					[
+						item.version,
+						pick(item, [
+							"peerDependencies",
+							"peerDependenciesMeta",
+							"deprecated",
+						]),
+					] as const,
+			)
+			.sort(([a], [b]) => compare(b, a)),
+	);
+}
+
+class Installer extends Service {
+	declare http: HTTP;
+	declare endpoint: string | undefined;
+	public fullCache: Dict<Dict<Pick<RemotePackage, DependencyMetaKey>>> = {};
+	public tempCache: Dict<Dict<Pick<RemotePackage, DependencyMetaKey>>> = {};
+
+	private pkgTasks: Dict<
+		Promise<Dict<Pick<RemotePackage, DependencyMetaKey>>>
+	> = {};
+	private agent = whichPMRuns();
+	private manifest: LocalPackage;
+	private declare depTask: Promise<Dict<Dependency>>;
+	private flushData: () => void;
+
+	override config: Installer.Config;
+
+	constructor(ctx: Context, config: Installer.Config) {
+		super(ctx, "installer");
+		this.config = config;
+		this.manifest = loadManifest(this.cwd);
+		this.flushData = ctx.throttle(() => {
+			ctx.get("console")?.broadcast("market/registry", this.tempCache);
+			this.tempCache = {};
+		}, 500);
+	}
+
+	get cwd() {
+		return this.ctx.baseDir;
+	}
+
+	override async start() {
+		const { endpoint, timeout } = this.config;
+		this.endpoint = endpoint ?? (await getRegistry());
+		const options: HTTP.Config = {};
+		if (this.endpoint) options.endpoint = this.endpoint;
+		if (timeout !== undefined) options.timeout = timeout;
+		this.http = this.ctx.http.extend(options);
+	}
+
+	resolveName(name: string) {
+		if (name.startsWith("@koishijs/plugin-")) return [name];
+		if (name.match(/(^|\/)koishi-plugin-/)) return [name];
+		if (name[0] === "@") {
+			const [left, right] = name.split("/");
+			return [`${left}/koishi-plugin-${right}`];
+		} else {
+			return [`@koishijs/plugin-${name}`, `koishi-plugin-${name}`];
+		}
+	}
+
+	async findVersion(names: string[]) {
+		const entries = await Promise.all(
+			names.map(async (name) => {
+				try {
+					const versions = Object.entries(await this.getPackage(name));
+					const [latest] = versions;
+					if (!latest) return undefined;
+					return { [name]: latest[0] };
+				} catch {
+					return undefined;
+				}
+			}),
+		);
+		return entries.find((entry): entry is Dict<string> => entry !== undefined);
+	}
+
+	private async _getPackage(name: string) {
+		try {
+			const registry = await this.http.get<Registry>(`/${name}`);
+			const versions = getVersions(
+				Object.values(registry.versions).filter((remote) => {
+					if (name === "koishi") return satisfies(remote.version, "4");
+					return !Scanner.isPlugin(name) || Scanner.isCompatible("4", remote);
+				}),
+			);
+			this.fullCache[name] = this.tempCache[name] = versions;
+			this.flushData();
+			return versions;
+		} catch (error) {
+			logger.warn(error);
+			return {};
+		}
+	}
+
+	setPackage(name: string, versions: RemotePackage[]) {
+		this.fullCache[name] = this.tempCache[name] = getVersions(versions);
+		this.flushData();
+		this.pkgTasks[name] = Promise.resolve(this.fullCache[name]);
+	}
+
+	getPackage(name: string) {
+		return (this.pkgTasks[name] ||= this._getPackage(name));
+	}
+
+	private async _getDeps() {
+		const result = valueMap(this.manifest.dependencies, (request) => {
+			return { request: request.replace(/^[~^]/, "") } as Dependency;
+		});
+		await pMap(
+			Object.keys(result),
+			async (name) => {
+				const dep = result[name];
+				if (!dep) return;
+				try {
+					// some dependencies may be left with no local installation
+					const meta = loadManifest(name);
+					dep.resolved = meta.version;
+					dep.workspace = meta.$workspace;
+					if (meta.$workspace) return;
+				} catch {}
+
+				if (!valid(dep.request)) {
+					dep.invalid = true;
+				}
+
+				const versions = await this.getPackage(name);
+				if (versions) dep.latest = Object.keys(versions)[0];
+			},
+			{ concurrency: 10 },
+		);
+		return result;
+	}
+
+	getDeps() {
+		return (this.depTask ||= this._getDeps());
+	}
+
+	refreshData() {
+		this.ctx.get("console")?.refresh("registry");
+		this.ctx.get("console")?.refresh("packages");
+	}
+
+	refresh(refresh = false) {
+		this.pkgTasks = {};
+		this.fullCache = {};
+		this.tempCache = {};
+		this.depTask = this._getDeps();
+		if (!refresh) return;
+		this.refreshData();
+	}
+
+	async exec(args: string[]) {
+		const name = this.agent?.name ?? "npm";
+		const useJson = name === "yarn" && (this.agent?.version ?? "1") >= "2";
+		if (name !== "yarn") args.unshift("install");
+		return new Promise<number>((resolve) => {
+			if (useJson) args.push("--json");
+			const child = spawn(name, args, { cwd: this.cwd });
+			child.on("exit", (code) => resolve(code ?? -1));
+			child.on("error", () => resolve(-1));
+
+			let stderr = "";
+			child.stderr?.on("data", (data) => {
+				data = stderr + data.toString();
+				const lines = data.split("\n");
+				stderr = lines.pop() ?? "";
+				for (const line of lines) {
+					logger.warn(line);
+				}
+			});
+
+			let stdout = "";
+			child.stdout?.on("data", (data) => {
+				data = stdout + data.toString();
+				const lines = data.split("\n");
+				stdout = lines.pop() ?? "";
+				for (const line of lines) {
+					if (!useJson || line[0] !== "{") {
+						logger.info(line);
+						continue;
+					}
+					try {
+						const { type, data } = JSON.parse(line) as YarnLog;
+						const level =
+							type in levelMap ? levelMap[type as keyof typeof levelMap] : null;
+						(level ? logger[level] : logger.info)(data);
+					} catch (error) {
+						logger.warn(line);
+						logger.warn(error);
+					}
+				}
+			});
+		});
+	}
+
+	async override(deps: Dict<string | null>) {
+		const filename = resolve(this.cwd, "package.json");
+		for (const key in deps) {
+			if (deps[key]) {
+				this.manifest.dependencies[key] = deps[key];
+			} else {
+				delete this.manifest.dependencies[key];
+			}
+		}
+		this.manifest.dependencies = Object.fromEntries(
+			Object.entries(this.manifest.dependencies).sort((a, b) =>
+				a[0].localeCompare(b[0]),
+			),
+		);
+		await Bun.write(filename, `${JSON.stringify(this.manifest, null, 2)}\n`);
+	}
+
+	private _install() {
+		const args: string[] = [];
+		if (this.endpoint) {
+			args.push("--registry", this.endpoint);
+		}
+		return this.exec(args);
+	}
+
+	private _getLocalDeps(override: Dict<string | null>) {
+		return valueMap(override, (request, name) => {
+			const dep = { request } as Dependency;
+			try {
+				const meta = loadManifest(name);
+				dep.resolved = meta.version;
+				dep.workspace = meta.$workspace;
+			} catch {}
+			return dep;
+		});
+	}
+
+	async install(deps: Dict<string | null>, forced?: boolean) {
+		const localDeps = this._getLocalDeps(deps);
+		await this.override(deps);
+
+		let shouldInstall = forced === true;
+		for (const name in deps) {
+			const request = deps[name];
+			const local = localDeps[name];
+			if (
+				local?.workspace ||
+				(request &&
+					local?.resolved &&
+					satisfies(local.resolved, request, { includePrerelease: true }))
+			)
+				continue;
+			shouldInstall = true;
+			break;
+		}
+
+		if (shouldInstall) {
+			const code = await this._install();
+			if (code) return code;
+		}
+
+		this.refresh();
+		const newDeps = await this.getDeps();
+		for (const name in localDeps) {
+			const local = localDeps[name];
+			const newDep = newDeps[name];
+			if (!local || !newDep || local.workspace) continue;
+			if (newDep.resolved === local.resolved) continue;
+			try {
+				if (!(require.resolve(name) in require.cache)) continue;
+			} catch (error) {
+				// FIXME https://github.com/koishijs/webui/issues/273
+				// I have no idea why this happens and how to fix it.
+				logger.error(error);
+			}
+			this.ctx.loader.fullReload();
+		}
+		this.refreshData();
+
+		return 0;
+	}
+
+	// erasableSyntaxOnly 禁止含运行时值的 namespace，
+	// 原 namespace 内的 Config 常量移到此处的静态字段，对外形状不变
+	static Config: Schema<Installer.Config> = Schema.object({
+		endpoint: Schema.string().role("link"),
+		timeout: Schema.number()
+			.role("time")
+			.default(Time.second * 5),
+	}); // TODO .hidden()
+}
+
+declare namespace Installer {
+	export interface Config {
+		endpoint?: string;
+		timeout?: number;
+	}
+}
+
+export default Installer;

package/src/node/locales/message.de-DE.yml

@@ -0,0 +1,25 @@
+commands.plugin:
+  description: 插件管理
+commands.plugin.install:
+  description: 安装插件
+  messages:
+    expect-name: 请输入插件名。
+    already-installed: 该插件已安装。
+    not-found: 未找到该插件。
+    success: 安装成功！
+commands.plugin.uninstall:
+  description: 卸载插件
+  messages:
+    expect-name: 请输入插件名。
+    not-installed: 该插件未安装。
+    success: 卸载成功！
+commands.plugin.upgrade:
+  description: 升级插件
+  options:
+    self: 升级 Koishi 本体
+  messages:
+    all-updated: 所有插件已是最新版本。
+    available: 有可用的依赖更新：
+    prompt: 输入「Y」升级全部依赖，输入「N」取消操作。
+    cancelled: 已取消操作。
+    success: 升级成功！

package/src/node/locales/message.en-US.yml

@@ -0,0 +1,25 @@
+commands.plugin:
+  description: Plugin management
+commands.plugin.install:
+  description: Install Plugins
+  messages:
+    expect-name: 请输入插件名。
+    already-installed: 该插件已安装。
+    not-found: 未找到该插件。
+    success: Installation Successful!
+commands.plugin.uninstall:
+  description: Uninstall plugin
+  messages:
+    expect-name: 请输入插件名。
+    not-installed: 该插件未安装。
+    success: 卸载成功！
+commands.plugin.upgrade:
+  description: Upgrade Plugin
+  options:
+    self: Upgrade Koishi core
+  messages:
+    all-updated: 所有插件已是最新版本。
+    available: 有可用的依赖更新：
+    prompt: 输入「Y」升级全部依赖，输入「N」取消操作。
+    cancelled: Operation canceled.
+    success: Upgrade Successful!

package/src/node/locales/message.fr-FR.yml

@@ -0,0 +1,25 @@
+commands.plugin:
+  description: 插件管理
+commands.plugin.install:
+  description: Installation de plugins
+  messages:
+    expect-name: 请输入插件名。
+    already-installed: 该插件已安装。
+    not-found: 未找到该插件。
+    success: 安装成功！
+commands.plugin.uninstall:
+  description: 卸载插件
+  messages:
+    expect-name: 请输入插件名。
+    not-installed: 该插件未安装。
+    success: 卸载成功！
+commands.plugin.upgrade:
+  description: 升级插件
+  options:
+    self: 升级 Koishi 本体
+  messages:
+    all-updated: 所有插件已是最新版本。
+    available: 有可用的依赖更新：
+    prompt: 输入「Y」升级全部依赖，输入「N」取消操作。
+    cancelled: 已取消操作。
+    success: 升级成功！