@build-script/package-tools 0.0.1

package/src/common/git/git.ts

@@ -0,0 +1,75 @@
+import { logger } from '@idlebox/logger';
+import { commandInPath, execLazyError, exists } from '@idlebox/node';
+import { rm } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { isVerbose } from '../functions/cli.js';
+
+export async function requireGitInPath() {
+	if (await commandInPath('git')) {
+	} else {
+		throw new Error('git必须在PATH中');
+	}
+}
+
+export class GitWorkingTree {
+	constructor(public readonly path: string) {}
+
+	protected _exec(cmds: string[]) {
+		return execLazyError('git', cmds, { cwd: this.path, verbose: isVerbose });
+	}
+
+	async init() {
+		logger.debug('初始化git工作区: %s', this.path);
+		const gitDir = resolve(this.path, '.git');
+		if (await exists(gitDir)) {
+			logger.debug('   - 删除已有.git文件夹');
+			await rm(gitDir, { recursive: true, force: true });
+		}
+		await this._exec(['init']);
+		await this._exec(['add', '.']);
+		await this._exec(['commit', '-m', 'Init']);
+		logger.debug('(初始化完成)');
+	}
+
+	async commitChanges() {
+		logger.debug('检测文件更改:');
+
+		const { stdout: testOut } = await this._exec(['status']);
+		const statusOut = testOut.toString().trim();
+		if (statusOut.includes('nothing to commit, working tree clean')) {
+			logger.debug('    git工作区状态: 干净');
+			return [];
+		}
+		// if (isDebugMode) {
+		// 	await execa('git', ['diff'], { cwd: this.path, stdio: ['ignore', 2, 2] });
+		// }
+		logger.debug('    git工作区状态: 有修改');
+
+		await this._exec(['add', '.']);
+		await this._exec(['commit', '-m', 'DetectChangedFiles']);
+
+		const { stdout } = await this._exec(['log', '--name-only', '-1']);
+		const lines = stdout
+			.toString()
+			.trim()
+			.split(/\n/g)
+			.map((i) => i.trim())
+			.filter((i) => i.length > 0);
+		const titleLine = lines.indexOf('DetectChangedFiles');
+		if (titleLine === -1) {
+			throw new Error('git commit - 未知错误');
+		}
+		const files = lines.slice(titleLine + 1);
+
+		logger.debug(
+			'    文件更改: %d 个 (%s%s)',
+			files.length,
+			files.slice(0, 5).join(', '),
+			files.length > 5 ? ' ...' : '',
+		);
+
+		return files.map((item) => {
+			return item.replace('Would remove ', '');
+		});
+	}
+}

package/src/common/package-manager/constant.ts

@@ -0,0 +1 @@
+export const DEFAULT_NPM_REGISTRY = 'https://registry.npmjs.org/';

package/src/common/package-manager/driver.abstract.ts

@@ -0,0 +1,162 @@
+import type { MonorepoWorkspace } from '@build-script/monorepo-lib';
+import { ensureLinkTarget } from '@idlebox/ensure-symlink';
+import { logger } from '@idlebox/logger';
+import { exists, writeFileIfChange } from '@idlebox/node';
+import { execa } from 'execa';
+import { dirname, resolve } from 'node:path';
+import { NpmCacheHandler } from '../cache/native.npm.js';
+import { registryInput } from '../functions/cli.js';
+import { TempWorkingFolder } from '../temp-work-folder.js';
+import { DEFAULT_NPM_REGISTRY } from './constant.js';
+import { cachedPackageJson } from './package-json.js';
+
+export interface IUploadResult {
+	name: string;
+	version: string;
+	published: boolean;
+}
+
+export enum PackageManagerUsageKind {
+	Read = 0,
+	Write = 1,
+}
+
+export abstract class PackageManager {
+	abstract readonly binary: string;
+	public readonly projectPath: string;
+	private readonly configTemp;
+
+	constructor(
+		public readonly usageKind: PackageManagerUsageKind,
+		public readonly workspace: MonorepoWorkspace,
+		subdir = process.cwd(),
+	) {
+		this.configTemp = new TempWorkingFolder(this.workspace, 'package-manager', true);
+		this.projectPath = resolve(workspace.root, subdir);
+		if (!this.projectPath.startsWith(workspace.root)) {
+			throw new Error(`project "${this.projectPath}" is outside the workspace root`);
+		}
+	}
+
+	public install() {
+		return execa(this.binary, ['install'], { cwd: this.projectPath, stdio: 'inherit' });
+	}
+
+	public pack(saveAs: string, packagePath = this.projectPath) {
+		logger.verbose(`打包项目: ${packagePath}`);
+		return this._pack(saveAs, packagePath);
+	}
+
+	protected abstract _pack(saveAs: string, packagePath: string): Promise<string>;
+
+	async loadPackageJson() {
+		return cachedPackageJson(resolve(this.projectPath, 'package.json'));
+	}
+
+	async getScope() {
+		const pkg = await this.loadPackageJson();
+		if (pkg.name?.startsWith('@')) {
+			const name = pkg.name.split('/')[0];
+			return name;
+		} else {
+			return undefined;
+		}
+	}
+
+	async getConfig(key: string): Promise<any> {
+		const pkgPublishConfig = this.workspace.getNpmRCPath(true);
+		if (this.usageKind === PackageManagerUsageKind.Read || !(await exists(pkgPublishConfig))) {
+			return this._get_config(dirname(this.workspace.getNpmRCPath(false)), key);
+		}
+
+		if (!this.configTemp.exists) {
+			await this.configTemp.mkdir();
+			await ensureLinkTarget(pkgPublishConfig, `${this.configTemp.path}/.npmrc`);
+			await writeFileIfChange(`${this.configTemp.path}/package.json`, '{}');
+		}
+
+		return this._get_config(this.configTemp.path, key);
+	}
+
+	private async _get_config(cwd: string, key: string) {
+		const scope = await this.getScope();
+		if (scope) {
+			const { stdout } = await this._execGetOut(cwd, ['config', 'get', `${scope}:${key}`]);
+			logger.debug('$ npm config get %s:%s -> %s', scope, key, stdout);
+			if (`${stdout}` !== 'undefined') {
+				return stdout;
+			}
+		}
+		const { stdout } = await this._execGetOut(cwd, ['config', 'get', key]);
+		logger.debug('$ npm config get %s -> %s', key, stdout);
+		return stdout === 'undefined' ? undefined : stdout;
+	}
+
+	protected abstract _uploadTarball(pack: string, cwd: string): Promise<IUploadResult>;
+	public async uploadTarball(pack: string, cwd: string = this.projectPath) {
+		logger.debug(`上传压缩包: ${pack}`);
+		try {
+			const r = await this._uploadTarball(pack, cwd);
+			logger.debug('    发布成功: %s @ %s [%s]', r.name, r.version, r.published);
+			return r;
+		} catch (e: any) {
+			logger.error`    tarball发布失败! ${e}`;
+			throw e;
+		}
+	}
+
+	protected async _execGetOut(cwd: string, cmds: string[], reject = true) {
+		const result = await execa(this.binary, cmds, {
+			stdio: ['ignore', 'pipe', 'pipe'],
+			cwd: cwd,
+			reject: reject,
+			stripFinalNewline: true,
+			encoding: 'utf8',
+			all: true,
+		});
+
+		return {
+			get stdout() {
+				return result.stdout.trim();
+			},
+			get stderr() {
+				return result.stderr.trim();
+			},
+			get all() {
+				return result.all.trim();
+			},
+		};
+	}
+
+	private _cachedReg?: string;
+	public async getNpmRegistry() {
+		if (!this._cachedReg) {
+			switch (registryInput) {
+				case 'detect':
+					logger.debug(`检测registry地址: ${registryInput}`);
+					this._cachedReg = await this.getConfig('registry');
+					break;
+				default:
+					if (!registryInput.startsWith('https://')) {
+						throw new Error(`不支持的--registry协议: ${registryInput}`);
+					}
+					logger.debug('使用命令行提供的registry地址 (%s)', registryInput);
+					this._cachedReg = registryInput;
+			}
+		}
+		return this._cachedReg || DEFAULT_NPM_REGISTRY;
+	}
+
+	private _cache_handler?: NpmCacheHandler;
+	async createCacheHandler() {
+		if (!this._cache_handler) {
+			const registry = await this.getNpmRegistry();
+
+			const path = await this.getConfig('cache');
+			if (!path) throw new Error('npm config get cache返回为空');
+
+			this._cache_handler = new NpmCacheHandler(this, registry, resolve(path, '_cacache'));
+		}
+		return this._cache_handler;
+	}
+}

package/src/common/package-manager/driver.npm.ts

@@ -0,0 +1,13 @@
+import { PackageManager, type IUploadResult } from './driver.abstract.js';
+
+export class NPM extends PackageManager {
+	override binary = 'npm';
+
+	override async _pack(_saveAs: string, _packagePath: string): Promise<string> {
+		throw new Error('Method not implemented.');
+	}
+
+	override async _uploadTarball(_pack: string, _cwd: string): Promise<IUploadResult> {
+		throw new Error('Method not implemented.');
+	}
+}

package/src/common/package-manager/driver.pnpm.ts

@@ -0,0 +1,113 @@
+import { prettyPrintError } from '@idlebox/common';
+import { logger } from '@idlebox/logger';
+import { execLazyError, exists } from '@idlebox/node';
+import { resolve } from 'node:path';
+import { isVerbose } from '../functions/cli.js';
+import { PackageManager, type IUploadResult } from './driver.abstract.js';
+
+interface IPnpmPublishResult {
+	id: string;
+	name: string;
+	version: string;
+	size: number;
+	unpackedSize: number;
+	shasum: string; // 'e320229fe019545b8e384ff19961de18d83c2673';
+	integrity: string; // 'sha512-0HwCZquIeAlDPVBfb9FEpvD+fzRaw+t7+K9L4cUKFi0l2NbClu/YnmBt9rJy/pdkkfcnuB1CS7lBfsUN6AwVCA==';
+	filename: string; // 'idlebox-common-1.4.2.tgz';
+	files: {
+		path: string;
+		size: number;
+		mode: number;
+	}[];
+	entryCount: number;
+	bundled: []; // ?
+}
+
+type RegistryErrorField = {
+	code: string;
+	summary: string;
+	detail: string;
+};
+class RegistryError extends Error {
+	constructor(private readonly error: RegistryErrorField) {
+		super(error.summary || 'no error summary');
+
+		if (this.error.detail) {
+			this.stack = this.error.detail;
+		}
+	}
+
+	get code() {
+		return this.error.code;
+	}
+}
+
+const duplicatePublishRegex = /You cannot publish over the previously published versions: (.+)/;
+const duplicatePublishOnUnpublishRegex = /Cannot publish over previously published version "(.+)"/;
+
+export class PNPM extends PackageManager {
+	override binary = 'pnpm';
+
+	override async _pack(saveAs: string, packagePath: string) {
+		const chProcess = await execLazyError(this.binary, ['pack', '--out', saveAs], {
+			cwd: packagePath,
+			verbose: isVerbose,
+			env: { LANG: 'C.UTF-8', LC_ALL: 'C.UTF-8' },
+		});
+		const lastLine = chProcess.stdout.trim().split('\n').pop();
+		if (!lastLine) {
+			throw new Error('impossible: string split empty?');
+		}
+		const output = resolve(packagePath, lastLine);
+
+		if (await exists(output)) {
+			return output;
+		}
+
+		throw new Error(`pnpm pack失败: ${output} 不存在`);
+	}
+
+	override async _uploadTarball(pack: string, cwd: string): Promise<IUploadResult> {
+		let result: IPnpmPublishResult;
+		const cmds = ['publish', pack, '--json', '--no-git-checks'];
+		const { stdout, all } = await this._execGetOut(cwd, cmds, false);
+		try {
+			const out = JSON.parse(stdout);
+			if (out.error) {
+				throw new RegistryError(out.error);
+			} else {
+				result = out;
+				if (!result.name || !result.version) {
+					logger.fatal`npm registry return invalid response:\n long<${stdout}>`;
+				}
+			}
+		} catch (e: any) {
+			if (e instanceof RegistryError) {
+				let dupVer: string | undefined;
+				dupVer = duplicatePublishRegex.exec(e.message)?.[1];
+				if (!dupVer) {
+					dupVer = duplicatePublishOnUnpublishRegex.exec(e.message)?.[1];
+				}
+				if (dupVer) {
+					return {
+						published: false,
+						name: '', // TODO
+						version: dupVer,
+					};
+				}
+			}
+
+			logger.warn`publish long<${pack}> error: ${e}`;
+			console.error(all);
+			prettyPrintError(`${this.binary} ${cmds.join(' ')}`, e);
+
+			throw e;
+		}
+
+		return {
+			published: true,
+			name: result.name,
+			version: result.version,
+		};
+	}
+}

package/src/common/package-manager/functions.ts

@@ -0,0 +1,117 @@
+import { getNpmConfigValue } from '@idlebox/node';
+import pacote from 'pacote';
+import asyncPool from 'tiny-async-pool';
+
+/**
+ * 将包规范字符串分割为包名和版本号
+ * @param value package spec, e.g. `@x/y@ver` or `@x/y`
+ */
+export function splitPackageSpecSimple(value: string) {
+	const at = value.indexOf('@', 1);
+	if (at === -1) return [value, '']; // @xxx/yyy | xxx
+	return [value.slice(0, at), value.slice(at + 1)]; // zzz@ver
+}
+
+export const isSingleVersionString = /^(?<prefix>[><]=?|[~^])?(?<version>(\d+\.)*\d+(-\S+)?)$/;
+
+/**
+ * 检查版本号是否是 version 或者 npm:@package@version 的格式
+ * 然后返回alias和version
+ */
+export function splitAliasVersion(version: string): [string, string] {
+	const m = version.match(isSingleVersionString);
+	if (m?.groups?.version) {
+		return ['', m.groups.version];
+	}
+
+	if (version.startsWith('npm:')) {
+		const [alias, ver] = splitPackageSpecSimple(version.slice(4));
+		const m = ver.match(isSingleVersionString);
+		if (m?.groups?.version) {
+			return [alias, m.groups.version];
+		}
+	}
+
+	return ['', ''];
+}
+
+async function resolveNpmVersion([packageName, currentVersion]: [string, string]) {
+	let lastError: any;
+	let packageReference = packageName;
+
+	if (currentVersion.startsWith('workspace:')) {
+		throw new Error('workspace package pass into npm resolver');
+	}
+
+	if (currentVersion.startsWith('npm:')) {
+		packageReference = currentVersion.substring(4);
+		const vsplit = packageReference.lastIndexOf('@');
+		if (vsplit > 1) {
+			packageReference = packageReference.substring(0, vsplit);
+		}
+	} else if (currentVersion.includes('/')) {
+		console.error('[npm:resolve] version of "%s: %s" is not supported', packageName, currentVersion);
+		return [packageName, currentVersion, currentVersion];
+	}
+
+	const d = new Date();
+	d.setMinutes(d.getMinutes() - 1);
+	let retryCnt = 5;
+	let currentTry = 0;
+	let maxRetry = 100;
+	while (--retryCnt && --maxRetry && ++currentTry) {
+		try {
+			const pkgjson = await pacote.manifest(`${packageReference}@latest`, { before: d });
+			let newVersion = `^${pkgjson.version}`;
+			if (packageReference !== packageName) {
+				newVersion = `npm:${packageReference}@${newVersion}`;
+			}
+
+			return [packageName, newVersion, currentVersion];
+		} catch (e: any) {
+			console.error(
+				'[npm:resolve][try %s] failed fetch package "%s": [%s] %s',
+				currentTry,
+				packageName,
+				e.code,
+				e.message
+			);
+			lastError = e;
+			if (e.code === 'ECONNRESET') {
+				retryCnt++;
+			} else if (e.code === 'E404') {
+				return [packageName, currentVersion, currentVersion];
+			}
+		}
+	}
+	throw lastError;
+}
+
+const cs = process.stdout.isTTY ? '\x1B[38;5;12m' : '';
+const ce = process.stdout.isTTY ? '\x1B[0m' : '';
+
+export async function resolveNpm(versions: Map<string, string>) {
+	let i = 1;
+	const total = versions.size;
+	const padto = total.toFixed(0).length;
+
+	const nc = Number.parseInt((await getNpmConfigValue('network-concurrency')) || '4');
+
+	for await (const [packName, newVersion, currentVersion] of asyncPool(
+		nc,
+		[...versions.entries()],
+		resolveNpmVersion
+	)) {
+		versions.set(packName, newVersion);
+
+		let updated = '';
+		if (currentVersion && currentVersion !== newVersion) {
+			updated = ` ${cs}(from ${currentVersion})${ce}`;
+		}
+
+		console.log(`  - [${i.toFixed().padStart(padto, ' ')}/${total}] ${packName}: ${newVersion}${updated}`);
+		i++;
+	}
+
+	return versions;
+}

package/src/common/package-manager/package-json.ts

@@ -0,0 +1,56 @@
+import type { IPackageJson } from '@idlebox/common';
+import { loadJsonFile, writeJsonFileBack } from '@idlebox/json-edit';
+import { logger } from '@idlebox/logger';
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { inc } from 'semver';
+
+function sort(object: any): any {
+	if (typeof object !== 'object') {
+		// Not to sort the array
+		return object;
+	}
+	if (Array.isArray(object)) {
+		return object.sort();
+	}
+	const keys = Object.keys(object);
+	keys.sort();
+	const newObject: any = {};
+	for (const key of keys) {
+		newObject[key] = sort(object[key]);
+	}
+	return newObject;
+}
+
+export async function makePackageJsonOrderConsistence(root: string) {
+	const filepath = resolve(root, 'package.json');
+	const data = JSON.parse(await readFile(filepath, 'utf-8'));
+	const json = sort(data);
+	await writeFile(filepath, JSON.stringify(json, null, 2), 'utf-8');
+
+	delete pkgCache[filepath];
+}
+
+const pkgCache: Record<string, IPackageJson> = {};
+export async function cachedPackageJson(path: string) {
+	const exists = pkgCache[path];
+	if (exists) {
+		return exists;
+	}
+
+	const data = await loadJsonFile(path);
+	pkgCache[path] = data;
+	return data;
+}
+
+export async function increaseVersion(pkg: IPackageJson, current: string) {
+	const v = inc(current, 'patch');
+	if (!v) {
+		throw new Error(`无法为"${pkg.name}"当前版本"${current}"增加版本号`);
+	}
+	pkg.version = v;
+	logger.log('新版本: %s', pkg.version);
+	const ch = await writeJsonFileBack(pkg);
+	logger.debug('package.json回写: %s', ch);
+	return v;
+}

package/src/common/package-manager/package-manager.ts

@@ -0,0 +1,46 @@
+import { createWorkspace, type MonorepoWorkspace } from '@build-script/monorepo-lib';
+import { commandInPath, PathEnvironment } from '@idlebox/node';
+import type { PackageManager, PackageManagerUsageKind } from './driver.abstract.js';
+import { NPM } from './driver.npm.js';
+import { PNPM } from './driver.pnpm.js';
+import { reconfigureProxyWithNpmrc } from './proxy.js';
+
+export type IPackageManager = PackageManager;
+
+type PackageManagerConstructor = new (
+	usage: PackageManagerUsageKind,
+	workspace: MonorepoWorkspace,
+	subdir?: string,
+) => IPackageManager;
+
+let pmCls: PackageManagerConstructor | undefined;
+
+export async function createPackageManager(
+	usage: PackageManagerUsageKind,
+	workspace?: MonorepoWorkspace,
+	subdir?: string,
+): Promise<IPackageManager> {
+	if (!workspace) workspace = await createWorkspace();
+
+	if (pmCls) {
+		return new pmCls(usage, workspace, subdir);
+	}
+
+	const supports: Record<string, PackageManagerConstructor> = { pnpm: PNPM, npm: NPM };
+	for (const [name, Cls] of Object.entries(supports)) {
+		if (!(await commandInPath(name).catch(() => false))) {
+			continue;
+		}
+
+		const pm = new Cls(usage, workspace, subdir);
+
+		await reconfigureProxyWithNpmrc(pm);
+
+		pmCls = Cls;
+		return pm;
+	}
+
+	const pathVar = new PathEnvironment();
+	console.log(`当前PATH: (${process.env.PATH})\n  - ${[...pathVar.values()].join('\n  - ')}`);
+	throw new Error(`未检测到任何包管理器，请在PATH中安装${Object.keys(supports).join('、')}`);
+}