@koishi-ce/plugin-market 1.1.3 → 1.2.0

package/src/node/installer/index.ts

@@ -33,11 +33,14 @@ import {
 	type RemotePackage,
 } from "@koishi-ce/registry";
 import { satisfies, valid } from "semver";
+import type { Dependency } from "../dependencies/types.ts";
 import { runBun } from "./exec.ts";
 import { findMissingDeps } from "./integrity.ts";
 import {
+	backupManifest,
 	type LocalPackage,
 	loadManifest,
+	restoreManifest,
 	writeManifest,
 } from "./manifest.ts";
 import {
@@ -52,24 +55,7 @@ import {
 
 const logger = new Logger("market");
 
-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 type { Dependency };
 
 class Installer extends Service {
 	declare http: HTTP;
@@ -78,8 +64,12 @@ class Installer extends Service {
 	public tempCache: Dict<VersionMap> = {};
 
 	private pkgTasks: Dict<Promise<VersionMap>> = {};
+	/** 各包最近一次拉取失败的归类（404 与否）；依赖页的 error 徽标消费 */
+	public pkgErrors: Dict<{ notFound: boolean }> = {};
 	private manifest: LocalPackage;
-	declare private depTask: Promise<Dict<Dependency>>;
+	declare private depTask:
+		| Promise<Dict<Dependency>>
+		| undefined;
 	private flushData: () => void;
 
 	override config: Installer.Config;
@@ -149,11 +139,23 @@ class Installer extends Service {
 	private async _getPackage(name: string) {
 		try {
 			const versions = await fetchVersions(this.http, name);
+			delete this.pkgErrors[name];
 			this.fullCache[name] = this.tempCache[name] =
 				versions;
 			this.flushData();
 			return versions;
 		} catch (error) {
+			// 404 与否决定负缓存策略：404 是 registry 的确定性答复，
+			// resolved 空表照常驻留 pkgTasks（会话内不再重试）；其余
+			// （网络抖动、超时等瞬态）清除任务让下次调用重试
+			const notFound =
+				this.http.isError(error) &&
+				error.response?.status === 404;
+			this.pkgErrors[name] = { notFound };
+			if (!notFound) {
+				// 本任务自身 catch 后恒 resolve，直接移除即可让下次调用重试
+				delete this.pkgTasks[name];
+			}
 			logger.warn(error);
 			return {};
 		}
@@ -217,6 +219,7 @@ class Installer extends Service {
 
 	refresh(refresh = false) {
 		this.pkgTasks = {};
+		this.pkgErrors = {};
 		this.fullCache = {};
 		this.tempCache = {};
 		this.depTask = this._getDeps();
@@ -224,6 +227,12 @@ class Installer extends Service {
 		this.refreshData();
 	}
 
+	/** 轻量重建：重读宿主清单并重置依赖汇总任务（registry 缓存不动）。 */
+	reload() {
+		this.manifest = loadManifest(this.cwd);
+		this.depTask = undefined;
+	}
+
 	async exec(args: string[]) {
 		// Bun-first：CE 生态只存在 bun 这一种包管理器，直接驱动 bun 执行
 		// 安装（上游经 which-pm-runs 探测 npm/yarn/bun，此处固定为 bun）
@@ -260,6 +269,8 @@ class Installer extends Service {
 		forced?: boolean,
 	) {
 		const localDeps = this._getLocalDeps(deps);
+		// 备份清单原文：主安装失败时整体还原，防止半改状态残留在磁盘
+		const backup = await backupManifest(this.cwd);
 		await this.override(deps);
 
 		let shouldInstall = forced === true;
@@ -281,7 +292,14 @@ class Installer extends Service {
 
 		if (shouldInstall) {
 			const code = await this._install();
-			if (code) return code;
+			if (code) {
+				// 安装失败：还原清单原文并轻量重建内存态
+				// （registry 缓存与依赖服务快照不受影响，后者由
+				// 安装监听器统一 refresh 触发重建）
+				await restoreManifest(this.cwd, backup);
+				this.reload();
+				return code;
+			}
 			// isolated 布局的增量安装可能漏建新包目录的依赖链接(机理
 			// 见 integrity.ts 模块注释):装完即校验,缺失时补跑一次
 			// 安装——bun 按磁盘实际状态重建链接,秒级自愈,无需人工

package/src/node/installer/installer.test.ts

@@ -0,0 +1,282 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2019-present Shigma and Koishijs contributors.
+// Copyright (c) 2026-present Koishi-CE contributors.
+
+import {
+	afterAll,
+	beforeAll,
+	describe,
+	expect,
+	it,
+} from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+	app,
+	itQuiet,
+	setNextExitCode,
+	setNextSpawnError,
+	spawnCalls,
+	startApp,
+	stopApp,
+	tmp,
+} from "../__tests__/helpers.ts";
+
+const { isResidentInCache } = await import(
+	"@koishi-ce/registry"
+);
+
+beforeAll(startApp);
+afterAll(stopApp);
+
+describe("Installer 安装链路", () => {
+	itQuiet(
+		"install 尊重护栏依赖并执行子进程安装",
+		async () => {
+			setNextExitCode(0);
+			spawnCalls.length = 0;
+			const code = await app.installer.install({
+				koishi: "2.0.0",
+				"market-alias": null,
+				"koishi-plugin-demo": "^1.0.0",
+			});
+			expect(code).toBe(0);
+			// 触发了包管理器安装（bun install --registry …）
+			expect(spawnCalls.length).toBe(1);
+			expect(spawnCalls[0]?.[0]).toBe("install");
+			// 重新读取临时 package.json：护栏项保持原样，新依赖加入
+			const manifest = JSON.parse(
+				await Bun.file(join(tmp, "package.json")).text(),
+			) as { dependencies: Record<string, string> };
+			expect(manifest.dependencies["koishi"]).toBe(
+				"workspace:*",
+			);
+			expect(manifest.dependencies["market-alias"]).toBe(
+				"npm:@koishi-ce/anything@^1.0.0",
+			);
+			expect(
+				manifest.dependencies["koishi-plugin-demo"],
+			).toBe("^1.0.0");
+		},
+		15000,
+	);
+
+	itQuiet(
+		"install 强制时无视本地满足也要装",
+		async () => {
+			setNextExitCode(0);
+			spawnCalls.length = 0;
+			const code = await app.installer.install(
+				{ "koishi-plugin-demo": "^1.0.0" },
+				true,
+			);
+			expect(code).toBe(0);
+			expect(spawnCalls.length).toBe(1);
+		},
+		15000,
+	);
+
+	itQuiet(
+		"子进程非零退出码向上传递",
+		async () => {
+			setNextExitCode(1);
+			spawnCalls.length = 0;
+			const code = await app.installer.install(
+				{ "koishi-plugin-demo": "^2.0.0" },
+				true,
+			);
+			expect(code).toBe(1);
+		},
+		15000,
+	);
+
+	itQuiet(
+		"安装失败时还原 package.json 备份(失败回滚链)",
+		async () => {
+			setNextExitCode(1);
+			const before = await Bun.file(
+				join(tmp, "package.json"),
+			).text();
+			const code = await app.installer.install(
+				{ "koishi-plugin-demo": "^2.0.0" },
+				true,
+			);
+			expect(code).toBe(1);
+			// 失败后清单原文原样还原(依赖改动不留半改状态)
+			const after = await Bun.file(
+				join(tmp, "package.json"),
+			).text();
+			expect(after).toBe(before);
+			// 内存清单同步重建:还原后的清单仍是 1.0.0 请求
+			const deps = await app.installer.getDeps();
+			expect(deps["koishi-plugin-demo"]?.request).toBe(
+				"1.0.0",
+			);
+			setNextExitCode(0);
+		},
+		15000,
+	);
+
+	itQuiet("子进程 spawn 失败返回 -1", async () => {
+		setNextSpawnError(true);
+		setNextExitCode(0);
+		const code = await app.installer.exec(["install"]);
+		setNextSpawnError(false);
+		expect(code).toBe(-1);
+	});
+
+	/** 在临时 node_modules 落盘一个带 dependencies 声明的校验用包 */
+	function placeLinkcheckPkg(
+		dependencies: Record<string, string>,
+	) {
+		const name = "koishi-plugin-linkcheck";
+		const pkgDir = join(tmp, "node_modules", name);
+		mkdirSync(pkgDir, { recursive: true });
+		writeFileSync(
+			join(pkgDir, "package.json"),
+			JSON.stringify({
+				name,
+				version: "1.0.0",
+				dependencies,
+			}),
+		);
+		return pkgDir;
+	}
+
+	itQuiet(
+		"装后依赖链接完整时不触发补装",
+		async () => {
+			setNextExitCode(0);
+			spawnCalls.length = 0;
+			const pkgDir = placeLinkcheckPkg({
+				"linkcheck-dep": "^1.0.0",
+			});
+			const depDir = join(
+				tmp,
+				"node_modules",
+				"linkcheck-dep",
+			);
+			mkdirSync(depDir, { recursive: true });
+			writeFileSync(
+				join(depDir, "package.json"),
+				JSON.stringify({
+					name: "linkcheck-dep",
+					version: "1.0.0",
+				}),
+			);
+			try {
+				const code = await app.installer.install(
+					{ "koishi-plugin-linkcheck": "^1.0.0" },
+					true,
+				);
+				expect(code).toBe(0);
+				expect(spawnCalls.length).toBe(1);
+			} finally {
+				rmSync(pkgDir, { recursive: true, force: true });
+				rmSync(depDir, { recursive: true, force: true });
+			}
+		},
+		15000,
+	);
+
+	itQuiet(
+		"包级依赖链接缺失时自动补装一次且不无限重试",
+		async () => {
+			setNextExitCode(0);
+			spawnCalls.length = 0;
+			// isolated 增量安装缺陷形态:包已落盘但声明的依赖未链接。
+			// 首装后校验命中补装一次;mock 安装不会真落盘依赖,二次校验
+			// 仍缺,只告警不再补装——总计恰好两次子进程调用
+			const pkgDir = placeLinkcheckPkg({
+				"linkcheck-missing": "^1.0.0",
+			});
+			try {
+				const code = await app.installer.install(
+					{ "koishi-plugin-linkcheck": "^1.0.0" },
+					true,
+				);
+				expect(code).toBe(0);
+				expect(spawnCalls.length).toBe(2);
+			} finally {
+				rmSync(pkgDir, { recursive: true, force: true });
+			}
+		},
+		15000,
+	);
+
+	itQuiet(
+		"alias 声明的依赖跳过链接校验",
+		async () => {
+			setNextExitCode(0);
+			spawnCalls.length = 0;
+			// alias 落盘名与键名无直接映射,不入校验,缺失也不触发补装
+			const pkgDir = placeLinkcheckPkg({
+				"linkcheck-alias": "npm:whatever@^1.0.0",
+			});
+			try {
+				const code = await app.installer.install(
+					{ "koishi-plugin-linkcheck": "^1.0.0" },
+					true,
+				);
+				expect(code).toBe(0);
+				expect(spawnCalls.length).toBe(1);
+			} finally {
+				rmSync(pkgDir, { recursive: true, force: true });
+			}
+		},
+		15000,
+	);
+
+	itQuiet(
+		"exec 收集子进程 stdout / stderr 输出行",
+		async () => {
+			setNextExitCode(0);
+			setNextSpawnError(false);
+			const code = await app.installer.exec(["install"]);
+			expect(code).toBe(0);
+		},
+	);
+});
+
+describe("isResidentInCache（装后重载判定）", () => {
+	/** 在临时 node_modules 放一个已安装包，返回其目录 */
+	function placePkg(name: string) {
+		const pkgDir = join(tmp, "node_modules", name);
+		mkdirSync(pkgDir, { recursive: true });
+		writeFileSync(
+			join(pkgDir, "package.json"),
+			JSON.stringify({
+				name,
+				version: "1.0.0",
+				main: "index.js",
+			}),
+		);
+		writeFileSync(
+			join(pkgDir, "index.js"),
+			"module.exports = {}",
+		);
+		return pkgDir;
+	}
+
+	it("包目录下有模块驻留 require.cache 时返回 true", () => {
+		const pkgDir = placePkg("koishi-plugin-resident-check");
+		// 入口经 require 进入 require.cache，模拟旧版本驻留内存
+		require(join(pkgDir, "index.js"));
+		expect(
+			isResidentInCache("koishi-plugin-resident-check"),
+		).toBe(true);
+	});
+
+	it("已安装但无模块驻留内存时返回 false", () => {
+		placePkg("koishi-plugin-idle-check");
+		expect(
+			isResidentInCache("koishi-plugin-idle-check"),
+		).toBe(false);
+	});
+
+	it("包不存在时保守返回 true（宁可多重载不漏判）", () => {
+		expect(
+			isResidentInCache("koishi-plugin-absent-check"),
+		).toBe(true);
+	});
+});

package/src/node/installer/manifest.ts

@@ -62,6 +62,21 @@ export function loadManifest(name: string): LocalPackage {
 	return meta;
 }
 
+/** 读取项目根 package.json 原文（安装前的备份快照）。 */
+export async function backupManifest(
+	cwd: string,
+): Promise<string> {
+	return Bun.file(resolve(cwd, "package.json")).text();
+}
+
+/** 把备份原文原样写回项目根 package.json（安装失败的回滚路径）。 */
+export async function restoreManifest(
+	cwd: string,
+	backup: string,
+): Promise<void> {
+	await Bun.write(resolve(cwd, "package.json"), backup);
+}
+
 /**
  * 把依赖增删写回项目根 package.json，返回写回后的清单。
  *