@build-script/package-tools 0.0.1

package/src/commands/monorepo-upgrade.ts

@@ -0,0 +1,131 @@
+import type { IPackageInfo } from '@build-script/monorepo-lib';
+import { loadJsonFile, writeJsonFileBack } from '@idlebox/json-edit';
+import { logger } from '@idlebox/logger';
+import { resolve } from 'node:path';
+import { argv, CommandDefine } from '../common/functions/cli.js';
+import { PackageManagerUsageKind } from '../common/package-manager/driver.abstract.js';
+import { resolveNpm, splitAliasVersion, splitPackageSpecSimple } from '../common/package-manager/functions.js';
+import { createPackageManager } from '../common/package-manager/package-manager.js';
+
+export class Command extends CommandDefine {
+	protected override _usage = '';
+	protected override _description = '更新monorepo中各个项目的所有依赖版本';
+	protected override _help = '被更新的包必须没有或者用^作为前缀';
+}
+
+export async function main() {
+	const dryRun = argv.flag('--dry') > 0;
+	const skipUpdate = argv.flag('--skip-update') > 0;
+
+	const packageManager = await createPackageManager(PackageManagerUsageKind.Read);
+	const projects = await packageManager.workspace.listPackages();
+
+	logger.log('Collecting local project versions:');
+	const alldeps: Record<string, string> = {};
+	for (const project of projects) {
+		const myDeps = { ...project.packageJson.dependencies, ...project.packageJson.devDependencies };
+		Object.assign(alldeps, filterDependencyToUpgrade(myDeps));
+
+		const size = Object.keys(myDeps).length;
+		logger.log(`  * ${project.name} -  ${size} dep${size > 1 ? 's' : ''}`);
+	}
+
+	logger.log('Resolving npm registry:');
+	const map = await resolveNpm(new Map(Object.entries(alldeps)));
+
+	logger.log('Write changed files:');
+	let hasSomeChange = 0;
+	for (const project of projects) {
+		const packageJson = await loadJsonFile(resolve(project.absolute, 'package.json'));
+
+		let numChange = 0;
+		numChange += update(project, packageJson.dependencies, map);
+		numChange += update(project, packageJson.devDependencies, map);
+
+		if (dryRun) {
+			logger.log(`  * ${project.name} -  ${numChange} change${numChange > 1 ? 's' : ''}`);
+			continue;
+		}
+
+		const changed = await writeJsonFileBack(packageJson);
+
+		if (changed) {
+			logger.log(`  * ${project.name} -  ${numChange} change${numChange > 1 ? 's' : ''}`);
+		}
+		hasSomeChange += numChange;
+	}
+
+	if (dryRun) {
+		logger.log('dry-run: quit now.');
+		return;
+	}
+
+	if (hasSomeChange === 0) {
+		logger.log('OHHHH! No update!');
+		return;
+	}
+
+	logger.log('Delete temp file(s):');
+
+	if (skipUpdate) {
+		logger.warn(`You should run "${packageManager.binary} update" now`);
+		return;
+	}
+
+	await packageManager.install();
+}
+
+/**
+ * @param target 被更新的dependencies对象
+ * @param map 解析后的版本号表
+ */
+function update(project: IPackageInfo, target: Record<string, string>, map: Map<string, string>) {
+	let changed = 0;
+	logger.log(`updating: ${project.name}`);
+	if (!target) return changed;
+	for (const [name, currVer] of Object.entries(target)) {
+		if (currVer.startsWith('workspace:')) continue;
+
+		let newVer = map.get(name);
+
+		if (currVer.startsWith('npm:')) {
+			// package alias
+			const [alias] = splitPackageSpecSimple(currVer.substring(4));
+			newVer = map.get(alias);
+			if (!newVer) {
+				// console.log('  - no version [%s] current [%s]', item, target[item]);
+				continue;
+			}
+			newVer = `npm:${alias}@${newVer}`;
+		}
+
+		if (currVer === newVer) continue;
+
+		if (newVer) {
+			console.log('  - update package [%s] from [%s] to [%s]', name, currVer, newVer);
+			target[name] = newVer;
+		} else {
+			// console.log('  - no version [%s] current [%s]', item, target[item]);
+			continue;
+		}
+
+		changed++;
+	}
+	return changed;
+}
+
+function filterDependencyToUpgrade(map: Record<string, string>) {
+	const clone: Record<string, string> = {};
+	for (const [name, version] of Object.entries(map)) {
+		if (version === '*' || version === '') {
+			continue;
+		}
+
+		const [alias, ver] = splitAliasVersion(version);
+
+		if (ver) {
+			clone[alias || name] = ver;
+		}
+	}
+	return clone;
+}

package/src/commands/run-if-version-mismatch.ts

@@ -0,0 +1,78 @@
+import type { IArgsReaderApi } from '@idlebox/args';
+import { logger } from '@idlebox/logger';
+import { checkChildProcessResult } from '@idlebox/node';
+import { execa } from 'execa';
+import { lt } from 'semver';
+import { CacheMode } from '../common/cache/native.npm.js';
+import { CommandDefine, distTagInput, pArgS, pDesc } from '../common/functions/cli.js';
+import { PackageManagerUsageKind } from '../common/package-manager/driver.abstract.js';
+import { createPackageManager } from '../common/package-manager/package-manager.js';
+
+process.env.COREPACK_ENABLE_STRICT = '0';
+
+export class Command extends CommandDefine {
+	protected override _usage = `${pArgS('--no-cache')} ${pArgS('--flush')} \x1B[38;5;9m--\x1B[0m command to run`;
+	protected override _description = '如果版本号改变，则运行命令';
+	protected override _help = `${pDesc('如果package.json中的version与npm上的版本(latest)不一致，则运行命令')}
+  注意: 命令行中的"--"是必须的
+`;
+	protected override _arguments = {
+		'--no-cache': { flag: true, description: '禁用缓存' },
+		'--flush': { flag: true, description: '程序成功退出时自动删除npm缓存' },
+		'--newer': { flag: true, description: '只有在本地版本号大于远程版本号时才运行（默认只要不同就运行）' },
+	};
+}
+export async function main(argv: IArgsReaderApi) {
+	const noCache = argv.flag('--no-cache') > 0;
+	const flushCache = argv.flag('--flush') > 0;
+	const onlyNewer = argv.flag('--newer') > 0;
+
+	const commands = argv.unused();
+	if (commands.length === 0 || !process.argv.includes('--')) {
+		logger.error(
+			'参数中必须包含"--"，并且后面跟随要运行的命令。\n  示例: run-if-version-mismatch --quiet -- pnpm publish',
+		);
+		return 22;
+	}
+	logger.debug('即将运行命令: %s', commands.join(' '));
+
+	const packageManager = await createPackageManager(PackageManagerUsageKind.Read);
+
+	const packagePath = await packageManager.workspace.getNearestPackage(process.cwd());
+	logger.log('工作目录: %s', packagePath);
+
+	const packageJson = await packageManager.loadPackageJson();
+	logger.log('包名: %s', packageJson.name);
+
+	const cache = await packageManager.createCacheHandler();
+	const pkg = await cache.fetchVersion(packageJson.name, distTagInput, noCache ? CacheMode.ForceNew : CacheMode.Normal);
+	const rversion = pkg?.version;
+	logger.log('远程版本: %s', rversion);
+
+	if (rversion) {
+		if (rversion === packageJson.version) {
+			logger.log('本地版本 (%s) === 远程版本 (%s)，无需操作，直接退出。', packageJson.version, rversion);
+			return 0;
+		}
+		if (onlyNewer && lt(packageJson.version, rversion)) {
+			logger.log('本地版本 (%s) < 远程版本 (%s)，无需操作，直接退出。', packageJson.version, rversion);
+			return 0;
+		}
+	}
+
+	logger.log('本地版本 (%s) !== 远程版本 (%s)，开始执行命令!', packageJson.version, rversion);
+	const r = await execa(commands[0], commands.slice(1), {
+		cwd: packagePath,
+		stdout: 'inherit',
+		stderr: 'inherit',
+	});
+
+	checkChildProcessResult(r);
+
+	if (flushCache) {
+		logger.log('刷新npm缓存...');
+		await cache.deleteMetadata(packageJson.name);
+	}
+
+	return 0;
+}

package/src/commands/sync-my-readme.ts

@@ -0,0 +1,56 @@
+import { findUpUntilSync, writeFileIfChangeSync } from '@idlebox/node';
+import { execaNode } from 'execa';
+import { readFileSync } from 'node:fs';
+import { CommandDefine } from '../common/functions/cli.js';
+
+export class Command extends CommandDefine {
+	protected override _usage = '';
+	protected override _description = '内部开发命令';
+	protected override _help = '';
+	public override isHidden = true;
+}
+
+export async function main() {
+	const result = await execaNode(process.argv[1], ['--help'], { all: true, encoding: 'utf8', stdio: 'pipe' });
+
+	const usageText = result.all.trim().replace(/\u001b.+?m/gu, '');
+
+	const readmeFile = findUpUntilSync({ file: 'README.md', from: import.meta.dirname });
+	if (!readmeFile) {
+		throw new Error('README.md not found');
+	}
+
+	const content = readFileSync(readmeFile, { encoding: 'utf8' }).split('\n');
+
+	const output_lines = [];
+	const start = '```text id="usage"';
+	const end = '```';
+
+	let found_start = false;
+	let found_end = false;
+	for (const line of content) {
+		if (!found_start && line === start) {
+			output_lines.push(line);
+			output_lines.push(usageText);
+			found_start = true;
+		} else if (found_start && !found_end) {
+			if (line === end) {
+				output_lines.push(line);
+				found_end = true;
+			}
+		} else {
+			output_lines.push(line);
+		}
+	}
+
+	if (!found_start || !found_end) {
+		throw new Error(`Cannot find usage section in ${readmeFile}`);
+	}
+
+	const ch = writeFileIfChangeSync(readmeFile, output_lines.join('\n'));
+	if (ch) {
+		console.log(`Updated ${readmeFile}`);
+	} else {
+		console.log(`No changes made to ${readmeFile}`);
+	}
+}

package/src/commands/test.ts

@@ -0,0 +1,18 @@
+import { CommandDefine } from '../common/functions/cli.js';
+import { PackageManagerUsageKind } from '../common/package-manager/driver.abstract.js';
+import { createPackageManager } from '../common/package-manager/package-manager.js';
+
+export class Command extends CommandDefine {
+	protected override _usage = '测试参数';
+	protected override _description = '测试命令';
+	protected override _help = '没有帮助信息';
+	public override isHidden = true;
+}
+
+export async function main() {
+	const pm = await createPackageManager(PackageManagerUsageKind.Read);
+	const cache = await pm.createCacheHandler();
+
+	const r = await cache.downloadTarball('react-dom', 'latest');
+	console.log(r);
+}

package/src/common/cache/escape-package-path.ts

@@ -0,0 +1,6 @@
+export function escapePackageNameToFilename(name: string) {
+	if (name.startsWith('@')) {
+		return name.slice(1).replace('/', '__');
+	}
+	return name;
+}

package/src/common/cache/native.npm.ts

@@ -0,0 +1,206 @@
+import { sleep, type IPackageJson } from '@idlebox/common';
+import { logger } from '@idlebox/logger';
+import { get as cacheGet, rm as cacheRm } from 'cacache';
+import { rm } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { resolve } from 'node:path';
+import { json as npmFetchJson } from 'npm-registry-fetch';
+import { DEFAULT_NPM_REGISTRY } from '../package-manager/constant.js';
+import type { IPackageManager } from '../package-manager/package-manager.js';
+import { getProxyValue } from '../package-manager/proxy.js';
+import { downloadFileCached } from '../taball/file-download.js';
+import { self_package_name, self_package_repository, self_package_version } from '../version.generated.js';
+import { escapePackageNameToFilename } from './escape-package-path.js';
+
+export interface IRegistryMetadata {
+	_attachments: any;
+	_id: string;
+	_rev: string;
+	author: IPackageJson['author'];
+	description: string;
+	'dist-tags': Record<string, string>;
+	license: string;
+	maintainers: IPackageJson['author'][];
+	name: string;
+	readme: string;
+	time: {
+		created: string;
+		modified: string;
+		[version: string]: string;
+	};
+	versions: Record<string, IPackageJson>;
+	bugs: IPackageJson['bugs'];
+	contributors: IPackageJson['contributors'];
+	homepage: string;
+	keywords: string[];
+	repository: IPackageJson['repository'];
+	_source_registry_name: string;
+}
+
+export class NpmCacheHandler {
+	constructor(
+		private readonly pm: IPackageManager,
+		private readonly registry: string,
+		public readonly path: string,
+	) {}
+
+	deleteMetadata(name: string) {
+		return deleteNpmCache(this.path, name, this.registry);
+	}
+
+	async fetchMetadata(name: string, cacheMode = CacheMode.Normal) {
+		const registry = await this.pm.getNpmRegistry();
+		return fetchNpmWithCache(this.path, name, registry, { mode: cacheMode });
+	}
+
+	async fetchVersion(name: string, distTag = 'latest', cacheMode = CacheMode.Normal) {
+		const json = await this.fetchMetadata(name, cacheMode);
+		if (!json) {
+			return;
+		}
+		const version = getVersion(json, distTag);
+		if (!version) {
+			logger.warn(` ! 找不到版本信息(${name}@${distTag})`);
+			return;
+		}
+		return version;
+	}
+
+	private getTarballFile(name: string, tag: string) {
+		const es = escapePackageNameToFilename(name);
+		return resolve(this.path, `../package-tools/${es}-${tag}.tgz`);
+	}
+
+	public async downloadTarball(name: string, distTag: string) {
+		const r = await this.fetchVersion(name, distTag);
+		if (!r) {
+			throw new Error(`无此版本: ${name} = ${distTag}`);
+		}
+		return await downloadFileCached(r.dist.tarball, this.getTarballFile(name, distTag));
+	}
+
+	public deleteTarball(name: string, distTag: string) {
+		return rm(this.getTarballFile(name, distTag), { force: true });
+	}
+}
+
+function getVersion(json: any, distTag: string): IPackageJson | undefined {
+	if (!json.versions) {
+		return undefined;
+	}
+	const v = json?.['dist-tags']?.[distTag];
+	if (!v) {
+		return json.versions[distTag];
+	}
+	return json.versions[v];
+}
+
+// type NpmLog = Exclude<FetchOptions['log'], undefined>;
+
+export enum CacheMode {
+	Normal = 'normal',
+	ForceNew = 'force-renew',
+	Offline = 'offline',
+}
+
+interface IMyOpts {
+	mode?: CacheMode;
+	maxRetry?: number;
+}
+const defOpt: Required<IMyOpts> = {
+	mode: CacheMode.Normal,
+	maxRetry: 3,
+};
+
+export async function fetchNpmWithCache(path: string, name: string, registry: string, _options?: IMyOpts) {
+	logger.debug(`   * npm-registry-fetch: ${registry} :: ${name}`);
+
+	const options: Required<IMyOpts> = Object.assign({}, defOpt, _options);
+
+	let try_cnt = 0;
+	let retry = options.maxRetry;
+	let retry_timeout = 500;
+	let json: IRegistryMetadata | undefined;
+
+	while (true) {
+		try_cnt++;
+		retry--;
+		try {
+			const proxy = getProxyValue(registry);
+			json = (await npmFetchJson(name, {
+				cache: path,
+				registry: registry,
+				fetchRetries: 0,
+				noProxy: false,
+				preferOnline: options.mode === CacheMode.ForceNew,
+				offline: options.mode === CacheMode.Offline,
+				preferOffline: options.mode === CacheMode.Normal,
+				proxy: proxy,
+				timeout: 5000,
+				userAgent: `${self_package_name}(${self_package_version}) GongT(${self_package_repository})`,
+			})) as any;
+			break;
+		} catch (e: any) {
+			if (!e || !e.message) {
+				console.dir(e);
+				throw new Error('npm fetch throw unexpected thing');
+			}
+			if (e.statusCode === 404) {
+				logger.verbose('registry say 404, return empty.');
+				return undefined;
+			}
+			if (e.code === 'ECONNRESET') retry++;
+
+			if (retry <= 0) throw e;
+
+			retry_timeout = (retry_timeout / 1000) * 1.2;
+			if (retry_timeout > 15000) retry_timeout = 15000;
+			logger.error(`failed fetch npm registry: ${e.message}, retry in ${(retry_timeout / 1000).toFixed(1)} seconds...`);
+			await sleep(retry_timeout);
+		}
+	}
+
+	if (!json) {
+		logger.error('[!!] NPM cache structure changed!');
+		process.exit(1);
+	}
+
+	return json;
+}
+
+async function deleteNpmCache(path: string, name: string, registry?: string) {
+	const require = createRequire(import.meta.url);
+	const cacheKey = require('make-fetch-happen/lib/cache/key.js');
+	const registries = new Set([DEFAULT_NPM_REGISTRY, 'https://registry.npmmirror.com/']);
+	if (registry) {
+		if (!registry.endsWith('/')) {
+			registry += '/';
+		}
+		registries.add(registry);
+	}
+
+	let deleted = false;
+	logger.debug(`  - delete cache: ${name}`);
+	let i = registries.size;
+	for (const registry of registries.values()) {
+		logger.debug(`     │ ${registry}${name}`);
+		const cid = cacheKey({ url: `${registry}${name}` });
+
+		i--;
+		const tc = i > 0 ? '├' : '└';
+
+		const info = await cacheGet.info(path, cid);
+		// console.log(info);
+		await cacheRm.content(path, cid);
+		// @types/cacache 最后一个参数丢失
+		await (cacheRm.entry as any)(path, cid, { removeFully: true });
+		if (info) {
+			logger.debug(`     ${tc}      deleted! ${cid}`);
+			deleted = true;
+		} else {
+			logger.debug(`     ${tc}      not exists: ${cid}`);
+		}
+	}
+
+	return deleted;
+}

package/src/common/functions/cli.ts

@@ -0,0 +1,145 @@
+import { createArgsReader } from '@idlebox/args';
+
+export const CSI = '\x1b[';
+
+export class DieError extends Error {
+	constructor(msg: string) {
+		super(msg);
+		this.stack = this.message;
+	}
+}
+function die(msg: string) {
+	throw new DieError(msg);
+}
+
+export const argv = createArgsReader(process.argv.slice(2));
+
+type ArgDefine = {
+	flag: boolean;
+	description: string;
+};
+const common_args = {
+	quiet: { flag: true, description: '减少输出' },
+	registry: { flag: false, description: 'npm服务器，默认从.npmrc读取(必须有schema://)' },
+	'dist-tag': { flag: false, description: '需要从服务器读取时使用的tag，默认为"latest"' },
+	package: { flag: false, description: '实际操作前，更改当前目录（此文件夹应包含package.json）' },
+	json: { flag: true, description: '输出json格式（部分命令支持）' },
+	help: { flag: true, description: '显示帮助信息' },
+};
+type CommonArgs = keyof typeof common_args;
+const all_common_args = Object.keys(common_args) as ReadonlyArray<CommonArgs>;
+
+export abstract class CommandDefine {
+	/**
+	 * 紧接在命令后面的参数
+	 */
+	protected abstract readonly _usage: string;
+	/**
+	 * usage后面的简短说明
+	 */
+	protected abstract readonly _description: string;
+	/**
+	 * 多行详细帮助信息
+	 */
+	protected abstract readonly _help: string;
+	/**
+	 * 独特命令行参数
+	 */
+	protected readonly _arguments?: Record<string, ArgDefine>;
+	/**
+	 * 通用命令行参数
+	 */
+	protected readonly _commonArgs?: readonly CommonArgs[];
+
+	public readonly isHidden: boolean = false;
+
+	get help() {
+		let r = this._help;
+		if (this._arguments) {
+			const opts = formatOptions(this._arguments);
+			if (r) r += '\n';
+			r += opts;
+		}
+		return r;
+	}
+
+	get usage() {
+		return this._usage;
+	}
+	get description() {
+		return this._description;
+	}
+	get commonArgs() {
+		return this._commonArgs;
+	}
+}
+
+export const isVerbose = argv.flag('--verbose') > 0;
+export const isQuiet = argv.flag(['--silent', '-s', '--quiet']) > 0;
+export const isJsonOutput = argv.flag('--json') > 0;
+export const isHelp = argv.flag(['--help', '-h']) > 0;
+export const distTagInput = argv.single('--dist-tag') || 'latest';
+export const registryInput = argv.single('--registry') || 'detect';
+export const isDebugMode = argv.flag('--debug') > 0;
+
+if (isVerbose && isQuiet) {
+	die('不能同时使用 --verbose 和 --quiet');
+}
+
+export function pArgS(s: string) {
+	return `\x1B[3;38;5;14m${s}\x1B[0m`;
+}
+export function pDesc(s: string) {
+	return `\x1B[3;2m${s}\x1B[0m`;
+}
+export function pCmd(s: string) {
+	return `\x1B[38;5;10m${s}\x1B[0m`;
+}
+
+export const mainCliController = {
+	command: undefined as CommandDefine | undefined,
+	setCommand(cmd: CommandDefine) {
+		this.command = cmd;
+	},
+};
+
+export function printCommonOptions() {
+	process.stderr.write('\x1B[2m通用参数\x1B[0m:\n');
+
+	const whitelist = mainCliController.command?.commonArgs ?? all_common_args;
+	const clone_common: Record<string, ArgDefine> = {};
+	for (const key of whitelist) {
+		clone_common[key] = common_args[key];
+	}
+
+	process.stderr.write(formatOptions(clone_common, { color: 3, indent: '  ' }));
+}
+
+interface IFormatOptions {
+	color?: number;
+	indent?: string;
+}
+export function formatOptions(args: Record<string, ArgDefine>, { color, indent }: IFormatOptions = {}) {
+	let r = '';
+	if (!color) color = 14;
+	if (!indent) indent = '';
+
+	for (const [name, { description, flag }] of Object.entries(args)) {
+		const names = name.split(',').map((n) => {
+			n = n.trim();
+			if (!n.startsWith('-')) {
+				if (n.length > 1) {
+					n = `--${n}`;
+				} else {
+					n = `-${n}`;
+				}
+			}
+			return n;
+		});
+
+		const flag_suffix = flag ? '' : ' <value>';
+
+		r += `${indent}\x1B[38;5;${color}m${names.join(', ')}${flag_suffix}\x1B[0m: ${description}\n`;
+	}
+	return r;
+}

package/src/common/functions/global-lifecycle.ts

@@ -0,0 +1,40 @@
+import { ensureDisposeGlobal } from '@idlebox/common';
+
+export let isApplicationShuttingDown = false;
+
+export function shutdown(code: number) {
+	if (isApplicationShuttingDown) {
+		process.exitCode = code || process.exitCode;
+		return;
+	}
+	isApplicationShuttingDown = true;
+	ensureDisposeGlobal().finally(() => {
+		process.exit(code || process.exitCode);
+	});
+}
+
+export let shutdownExtraErase = 0;
+
+export function registerShutdownHandlers() {
+	process.on('unhandledRejection', (reason, promise) => {
+		console.error('got unhandledRejection: %s', reason);
+		console.error(promise);
+		shutdown(1);
+	});
+
+	process.on('SIGINT', () => {
+		console.error('\ngot SIGINT');
+		shutdownExtraErase += 2;
+		shutdown(0);
+	});
+
+	process.on('SIGTERM', () => {
+		console.error('\ngot SIGTERM');
+		shutdownExtraErase += 2;
+		shutdown(0);
+	});
+
+	process.on('beforeExit', (code) => {
+		shutdown(code);
+	});
+}