@koishi-ce/plugin-market 1.0.0

package/lib/index.mjs

@@ -0,0 +1,513 @@
+import { createRequire } from "node:module";
+import { resolve } from "node:path";
+import { Logger, Schema, Service, Time, defineProperty, pick, valueMap } from "@koishi-ce/koishi";
+import { compare, gt, satisfies, valid } from "semver";
+import { DataService } from "@koishi-ce/console";
+import { readFileSync } from "node:fs";
+import Scanner from "@koishi-ce/registry";
+import spawn from "execa";
+import getRegistry from "get-registry";
+import pMap from "p-map";
+import messageZhCN from "./assets/message.zh-CN-B_nH77kB.yml";
+import schemaZhCN from "./assets/schema.zh-CN-CLU01Lrj.yml";
+//#region \0rolldown/runtime.js
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+//#region src/node/deps.ts
+var DependencyProvider = class extends DataService {
+	constructor(ctx) {
+		super(ctx, "dependencies", { authority: 4 });
+	}
+	async get() {
+		return this.ctx.installer.getDeps();
+	}
+};
+var RegistryProvider = class extends DataService {
+	constructor(ctx) {
+		super(ctx, "registry", { authority: 4 });
+	}
+	async get() {
+		return this.ctx.installer.fullCache;
+	}
+};
+//#endregion
+//#region src/node/installer.ts
+const logger$1 = new Logger("market");
+const whichPMRuns = createRequire(import.meta.url)("which-pm-runs");
+const levelMap = {
+	info: "info",
+	warning: "debug",
+	error: "warn"
+};
+function loadManifest(name) {
+	const filename = __require.resolve(`${name}/package.json`);
+	const meta = JSON.parse(readFileSync(filename, "utf8"));
+	meta.dependencies ||= {};
+	defineProperty(meta, "$workspace", !filename.includes("node_modules"));
+	return meta;
+}
+function getVersions(versions) {
+	return Object.fromEntries(versions.map((item) => [item.version, pick(item, [
+		"peerDependencies",
+		"peerDependenciesMeta",
+		"deprecated"
+	])]).sort(([a], [b]) => compare(b, a)));
+}
+var Installer = class extends Service {
+	fullCache = {};
+	tempCache = {};
+	pkgTasks = {};
+	agent = whichPMRuns();
+	manifest;
+	flushData;
+	config;
+	constructor(ctx, 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;
+	}
+	async start() {
+		const { endpoint, timeout } = this.config;
+		this.endpoint = endpoint ?? await getRegistry();
+		const options = {};
+		if (this.endpoint) options.endpoint = this.endpoint;
+		if (timeout !== void 0) options.timeout = timeout;
+		this.http = this.ctx.http.extend(options);
+	}
+	resolveName(name) {
+		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) {
+		return (await Promise.all(names.map(async (name) => {
+			try {
+				const [latest] = Object.entries(await this.getPackage(name));
+				if (!latest) return void 0;
+				return { [name]: latest[0] };
+			} catch {
+				return;
+			}
+		}))).find((entry) => entry !== void 0);
+	}
+	async _getPackage(name) {
+		try {
+			const registry = await this.http.get(`/${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$1.warn(error);
+			return {};
+		}
+	}
+	setPackage(name, versions) {
+		this.fullCache[name] = this.tempCache[name] = getVersions(versions);
+		this.flushData();
+		this.pkgTasks[name] = Promise.resolve(this.fullCache[name]);
+	}
+	getPackage(name) {
+		return this.pkgTasks[name] ||= this._getPackage(name);
+	}
+	async _getDeps() {
+		const result = valueMap(this.manifest.dependencies, (request) => {
+			return { request: request.replace(/^[~^]/, "") };
+		});
+		await pMap(Object.keys(result), async (name) => {
+			const dep = result[name];
+			if (!dep) return;
+			try {
+				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) {
+		const name = this.agent?.name ?? "npm";
+		const useJson = name === "yarn" && (this.agent?.version ?? "1") >= "2";
+		if (name !== "yarn") args.unshift("install");
+		return new Promise((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$1.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$1.info(line);
+						continue;
+					}
+					try {
+						const { type, data } = JSON.parse(line);
+						const level = type in levelMap ? levelMap[type] : null;
+						(level ? logger$1[level] : logger$1.info)(data);
+					} catch (error) {
+						logger$1.warn(line);
+						logger$1.warn(error);
+					}
+				}
+			});
+		});
+	}
+	async override(deps) {
+		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`);
+	}
+	_install() {
+		const args = [];
+		if (this.endpoint) args.push("--registry", this.endpoint);
+		return this.exec(args);
+	}
+	_getLocalDeps(override) {
+		return valueMap(override, (request, name) => {
+			const dep = { request };
+			try {
+				const meta = loadManifest(name);
+				dep.resolved = meta.version;
+				dep.workspace = meta.$workspace;
+			} catch {}
+			return dep;
+		});
+	}
+	async install(deps, forced) {
+		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) {
+				logger$1.error(error);
+			}
+			this.ctx.loader.fullReload();
+		}
+		this.refreshData();
+		return 0;
+	}
+	static Config = Schema.object({
+		endpoint: Schema.string().role("link"),
+		timeout: Schema.number().role("time").default(Time.second * 5)
+	});
+};
+//#endregion
+//#region src/shared/index.ts
+const logger = new Logger("market");
+var MarketProvider = class extends DataService {
+	_task = null;
+	_timestamp = 0;
+	_error;
+	constructor(ctx) {
+		super(ctx, "market", { authority: 4 });
+		ctx.console.addListener("market/refresh", () => this.start(true), { authority: 4 });
+		ctx.on("console/connection", async (client) => {
+			if (!ctx.console.clients[client.id]) return;
+			if (Date.now() - this._timestamp <= Time.hour * 12) return;
+			if (await this.ctx.serial("console/intercept", client, { authority: 4 })) return;
+			this.start();
+		});
+	}
+	start(_refresh = false) {
+		this._task = null;
+		this._error = null;
+		this._timestamp = Date.now();
+		this.refresh();
+	}
+	async prepare() {
+		return this._task ||= this.collect().catch((error) => {
+			logger.warn(error);
+			this._error = error;
+		});
+	}
+};
+//#endregion
+//#region src/node/market.ts
+var MarketProvider$1 = class extends MarketProvider {
+	http;
+	failed = [];
+	scanner;
+	fullCache = {};
+	tempCache = {};
+	flushData;
+	config;
+	constructor(ctx, config) {
+		super(ctx);
+		this.config = config;
+		if (config.endpoint) this.http = ctx.http.extend(config);
+		this.flushData = ctx.throttle(() => {
+			ctx.console.broadcast("market/patch", {
+				data: this.tempCache,
+				failed: this.failed.length,
+				total: this.scanner.total,
+				progress: this.scanner.progress
+			});
+			this.tempCache = {};
+		}, 500);
+	}
+	async start(refresh = false) {
+		this.failed = [];
+		this.fullCache = {};
+		this.tempCache = {};
+		if (refresh) this.ctx.installer.refresh(true);
+		await this.prepare();
+		super.start();
+	}
+	async collect() {
+		const { timeout } = this.config;
+		const registry = this.ctx.installer.http;
+		this.failed = [];
+		this.scanner = new Scanner(registry.get);
+		if (this.http) {
+			const result = await this.http.get("");
+			this.scanner.objects = result.objects.filter((object) => !object.ignored);
+			this.scanner.total = this.scanner.objects.length;
+			if (result.version !== void 0) this.scanner.version = result.version;
+		} else await this.scanner.collect(timeout !== void 0 ? { timeout } : {});
+		if (!this.scanner.version) {
+			let isNpmmirror = false;
+			try {
+				isNpmmirror = new URL(registry.config.endpoint ?? "").origin === "https://registry.npmmirror.com";
+			} catch {}
+			this.scanner.analyze({
+				version: "4",
+				onFailure: (name, reason) => {
+					this.failed.push(name);
+					if (isNpmmirror) {
+						if (this.ctx.http.isError(reason) && reason.response?.status === 404) {}
+					}
+				},
+				onRegistry: (registry, versions) => {
+					this.ctx.installer.setPackage(registry.name, versions);
+				},
+				onSuccess: (object, _versions) => {
+					object.package.links ||= { npm: `${registry.config.endpoint?.replace("registry.", "www.") ?? ""}/package/${object.package.name}` };
+					this.fullCache[object.package.name] = this.tempCache[object.package.name] = object;
+				},
+				after: () => this.flushData()
+			});
+		}
+	}
+	async get() {
+		await this.prepare();
+		if (this._error) return {
+			data: {},
+			failed: 0,
+			total: 0,
+			progress: 0
+		};
+		const gravatar = process.env["GRAVATAR_MIRROR"];
+		return this.scanner.version ? {
+			registry: this.ctx.installer.endpoint,
+			data: Object.fromEntries(this.scanner.objects.map((item) => [item.package.name, item])),
+			failed: 0,
+			total: this.scanner.total,
+			progress: this.scanner.total,
+			gravatar
+		} : {
+			registry: this.ctx.installer.endpoint,
+			data: this.fullCache,
+			failed: this.failed.length,
+			total: this.scanner.total,
+			progress: this.scanner.progress,
+			gravatar
+		};
+	}
+	static Config = Schema.object({
+		endpoint: Schema.string().role("link"),
+		timeout: Schema.number().role("time").default(Time.second * 30),
+		proxyAgent: Schema.string().role("link")
+	});
+};
+//#endregion
+//#region src/node/index.ts
+const name = "market";
+const inject = ["http"];
+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)。`;
+const Config = Schema.object({
+	registry: Installer.Config,
+	search: MarketProvider$1.Config
+}).i18n({ "zh-CN": schemaZhCN });
+function apply(ctx, 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");
+			const names = ctx.installer.resolveName(name);
+			const deps = await ctx.installer.getDeps();
+			if (names.find((name) => deps[name])) return session.text(".already-installed");
+			const result = await ctx.installer.findVersion(names);
+			if (!result) return session.text(".not-found");
+			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");
+			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) {
+				if (!names.length) return Object.keys(deps);
+				const resolved = names.map((name) => {
+					return ctx.installer.resolveName(name).find((name) => deps[name]);
+				}).filter((name) => name !== void 0);
+				if (options?.self) resolved.push("koishi");
+				return resolved;
+			}
+			ctx.installer.refresh(true);
+			const deps = await ctx.installer.getDeps();
+			names = (await getPackages(names.filter((name) => !!name))).filter((name) => {
+				const { latest, resolved, invalid } = deps[name] ?? {};
+				if (latest === void 0 || resolved === void 0) 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 answer = (await session.prompt())?.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((result, name) => {
+				const latest = deps[name]?.latest;
+				if (latest !== void 0) 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$1, 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 });
+	});
+}
+//#endregion
+export { Config, DependencyProvider, Installer, MarketProvider, RegistryProvider, apply, inject, name, usage };

package/package.json

@@ -0,0 +1,88 @@
+{
+    "name": "@koishi-ce/plugin-market",
+    "description": "Manage your bots and plugins with console",
+    "version": "1.0.0",
+    "type": "module",
+    "main": "lib/index.mjs",
+    "typings": "lib/index.d.ts",
+    "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/market"
+    },
+    "bugs": {
+        "url": "https://github.com/Koishi-CE/koishi/issues"
+    },
+    "homepage": "https://koishi.chat/plugins/console/market.html",
+    "keywords": [
+        "bot",
+        "chatbot",
+        "koishi",
+        "plugin",
+        "market",
+        "manager",
+        "server"
+    ],
+    "koishi": {
+        "public": [
+            "dist"
+        ],
+        "description": {
+            "en": "Manage your plugins with console",
+            "zh": "使用控制台安装、卸载、更新你的插件"
+        },
+        "service": {
+            "optional": [
+                "console"
+            ],
+            "implements": [
+                "installer"
+            ]
+        }
+    },
+    "peerDependencies": {
+        "@koishijs/plugin-console": "^5.30.11",
+        "koishi": "^4.18.11"
+    },
+    "peerDependenciesMeta": {
+        "@koishijs/plugin-console": {
+            "optional": true
+        }
+    },
+    "devDependencies": {
+        "@koishi-ce/client": "^1.0.0",
+        "@koishi-ce/loader": "^1.0.0",
+        "@koishi-ce/plugin-config": "^1.0.0",
+        "@koishijs/market": "^4.2.10",
+        "@types/semver": "^7.5.8",
+        "vue": "^3.5.12"
+    },
+    "dependencies": {
+        "@koishi-ce/console": "^1.0.0",
+        "@koishi-ce/registry": "^1.0.0",
+        "execa": "^5.1.1",
+        "get-registry": "^1.2.0",
+        "p-map": "^4.0.0",
+        "semver": "^7.6.3",
+        "which-pm-runs": "^1.1.0"
+    },
+    "exports": {
+        ".": {
+            "source": "./src/index.ts",
+            "types": "./lib/index.d.ts",
+            "import": "./lib/index.mjs",
+            "default": "./lib/index.mjs"
+        },
+        "./package.json": "./package.json"
+    }
+}

package/src/browser/index.ts

@@ -0,0 +1,26 @@
+import { type Context, Schema } from "@koishi-ce/koishi";
+import MarketProvider from "./market.ts";
+
+export * from "../shared/index.ts";
+export * from "./market.ts";
+
+export { MarketProvider };
+
+export const filter = false;
+export const name = "market";
+export const inject = ["console"];
+
+export type Config = Record<never, never>;
+
+export const Config: Schema<Config> = Schema.object({});
+
+export function apply(ctx: Context, _config: Config) {
+	ctx.plugin(MarketProvider);
+
+	const base = process.env["KOISHI_BASE"];
+	ctx.console.addEntry(
+		base
+			? [`${base}/dist/index.js`, `${base}/dist/style.css`]
+			: [import.meta.url.replace(/\/src\/[^/]+\/[^/]+$/, "/client/index.ts")],
+	);
+}

package/src/browser/market.ts

@@ -0,0 +1,21 @@
+import type {} from "@koishi-ce/plugin-config";
+import { MarketProvider as BaseMarketProvider } from "../shared/index.ts";
+
+export default class MarketProvider extends BaseMarketProvider {
+	async collect() {
+		return this.ctx.loader.market;
+	}
+
+	override async get() {
+		const market = await this.prepare();
+		if (!market) return { data: {}, failed: 0, total: 0, progress: 0 };
+		return {
+			data: Object.fromEntries(
+				market.objects.map((item) => [item.package.name, item]),
+			),
+			failed: 0,
+			total: market.objects.length,
+			progress: market.objects.length,
+		};
+	}
+}

package/src/index.ts

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

package/src/node/deps.ts

@@ -0,0 +1,28 @@
+import { DataService } from "@koishi-ce/console";
+import type { Context, Dict } from "@koishi-ce/koishi";
+import type { DependencyMetaKey, RemotePackage } from "@koishi-ce/registry";
+import type { Dependency } from "./installer.ts";
+
+class DependencyProvider extends DataService<Dict<Dependency>> {
+	constructor(ctx: Context) {
+		super(ctx, "dependencies", { authority: 4 });
+	}
+
+	override async get() {
+		return this.ctx.installer.getDeps();
+	}
+}
+
+class RegistryProvider extends DataService<
+	Dict<Dict<Pick<RemotePackage, DependencyMetaKey>>>
+> {
+	constructor(ctx: Context) {
+		super(ctx, "registry", { authority: 4 });
+	}
+
+	override async get() {
+		return this.ctx.installer.fullCache;
+	}
+}
+
+export { DependencyProvider, RegistryProvider };