@build-script/package-tools 0.0.1

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

@@ -0,0 +1,129 @@
+import { escapeRegExp } from '@idlebox/common';
+import { logger } from '@idlebox/logger';
+import { getEnvironment } from '@idlebox/node';
+import type { IPackageManager } from './package-manager.js';
+
+let proxy_override_by_env = false;
+
+function makeRe(str: string) {
+	const reTxt = str
+		.split('*')
+		.map((v) => escapeRegExp(v))
+		.join('.+');
+	return new RegExp(`^${reTxt}$`, 'i');
+}
+
+export function getProxyValue(url: string) {
+	const proxyValue = process.env.http_proxy;
+	if (!proxyValue) {
+		return '';
+	}
+	logger.verbose`get proxy for: ${url}`;
+	if (!process.env.no_proxy) {
+		logger.verbose`using http_proxy directly`;
+		return proxyValue;
+	}
+
+	let domain: string;
+	if (url.includes('://')) {
+		domain = new URL(url).hostname;
+	} else {
+		domain = url.split('/')[0];
+	}
+	if (!domain) {
+		throw new Error(`无法从URL中获取域名: ${url}`);
+	}
+
+	logger.verbose`  trying no_proxy: ${process.env.no_proxy} | ${domain}`;
+
+	const noProxy = process.env.no_proxy.split(',').map((s) => s.trim());
+	for (const npPart of noProxy) {
+		logger.verbose`- ${npPart}`;
+		if (npPart.includes('*')) {
+			const re = makeRe(npPart);
+			if (re.test(domain)) {
+				logger.verbose(`  hit regexp`);
+				return '';
+			}
+		} else {
+			if (domain === npPart) {
+				logger.verbose(`  hit equals`);
+				return '';
+			}
+			const domainEnding = npPart[0] === '.' ? npPart : '.' + npPart;
+			if (domain.endsWith(domainEnding)) {
+				logger.verbose(`  hit ending: ${domainEnding}`);
+				return '';
+			}
+		}
+	}
+
+	logger.verbose`  not hit no_proxy, using http_proxy`;
+	return proxyValue;
+}
+
+export async function reconfigureProxyWithNpmrc(pm: IPackageManager) {
+	if (proxy_override_by_env) return;
+
+	logger.debug('通过npm设置代理服务器:');
+	const p = await pm.getConfig('proxy');
+	const np = await pm.getConfig('noproxy');
+
+	if (p) {
+		logger.debug(`   * proxy server = ${p}`);
+	}
+	if (np) {
+		logger.debug(`   * no_proxy = ${np}`);
+	}
+
+	applyEnv(p || '', np || '');
+}
+
+export function configureProxyFromEnvironment() {
+	// bootstrap({
+	// 	environmentVariableNamespace: '',
+	// 	forceGlobalAgent: true,
+	// 	socketConnectionTimeout: 1000,
+	// });
+
+	logger.debug('通过环境变量设置代理服务器:');
+
+	let noProxy = '';
+	const envVar = getEnvironment('NO_PROXY');
+	if (envVar.value) {
+		logger.debug(`   * no_proxy = ${envVar.value}`);
+
+		noProxy = envVar.value;
+	} else {
+		noProxy = '';
+		logger.debug('   * no_proxy = <unset>');
+	}
+
+	let httpProxy = getEnvironment('http_proxy').value || '';
+	if (!httpProxy) {
+		httpProxy = getEnvironment('https_proxy').value || '';
+		if (!httpProxy) {
+			httpProxy = getEnvironment('all_proxy').value || '';
+			if (!httpProxy) {
+				httpProxy = getEnvironment('proxy').value || '';
+			}
+		}
+	}
+
+	if (httpProxy) {
+		logger.debug(`   * proxy server = ${httpProxy}`);
+		proxy_override_by_env = true;
+		applyEnv(httpProxy, noProxy);
+	} else {
+		logger.debug('   * proxy server = <unset>');
+		proxy_override_by_env = false;
+		applyEnv('', '');
+	}
+}
+
+function applyEnv(proxy: string, noproxy: string) {
+	process.env.http_proxy = proxy;
+	process.env.https_proxy = proxy;
+	process.env.all_proxy = proxy;
+	process.env.no_proxy = noproxy;
+}

package/src/common/shared-jobs/cnpm-sync.ts

@@ -0,0 +1,57 @@
+import type { IPackageInfo } from '@build-script/monorepo-lib';
+import { logger } from '@idlebox/logger';
+import { checkChildProcessResult, printLine } from '@idlebox/node';
+import { execa } from 'execa';
+import { CSI, isQuiet } from '../functions/cli.js';
+
+export function cnpmSync(list: ReadonlyArray<IPackageInfo>, collectOutput = isQuiet, dryRun = false) {
+	const names = list
+		.filter((e) => {
+			return !!e.packageJson.name && !e.packageJson.private;
+		})
+		.map((e) => e.packageJson.name);
+
+	return cnpmSyncNames(names, collectOutput, dryRun);
+}
+
+export async function cnpmSyncNames(names: ReadonlyArray<string>, collectOutput = isQuiet, dryRun = false) {
+	console.log(`🔃 cnpm同步${names.length}个包`);
+
+	if (dryRun) {
+		console.log('');
+		console.log('');
+		console.log('cnpm sync', ...names.map((value) => JSON.stringify(value)));
+		console.log('');
+
+		return;
+	}
+	const p = await execa('cnpm', ['sync', ...names], {
+		stdio: collectOutput ? 'pipe' : 'inherit',
+		buffer: collectOutput,
+		all: collectOutput,
+		fail: false,
+		verbose: 'short',
+		env: {
+			http_proxy: undefined,
+			https_proxy: undefined,
+			all_proxy: undefined,
+			HTTP_PROXY: undefined,
+			HTTPS_PROXY: undefined,
+			ALL_PROXY: undefined,
+		},
+	});
+
+	try {
+		checkChildProcessResult(p);
+		if (collectOutput) {
+			process.stderr.write(`${CSI}K`);
+		}
+		console.log('    ✨ cnpm同步请求成功');
+	} catch (e) {
+		if (collectOutput) {
+			printLine();
+			logger.error(p.all as any);
+		}
+		console.log('    ⚠️ cnpm同步请求失败');
+	}
+}

package/src/common/shared-jobs/detect-change-job.ts

@@ -0,0 +1,76 @@
+import { logger } from '@idlebox/logger';
+import { PathEnvironment } from '@idlebox/node';
+import { resolve } from 'node:path';
+import { gt } from 'semver';
+import { distTagInput } from '../functions/cli.js';
+import { GitWorkingTree } from '../git/git.js';
+import { makePackageJsonOrderConsistence } from '../package-manager/package-json.js';
+import type { IPackageManager } from '../package-manager/package-manager.js';
+import { TempWorkingFolder } from '../temp-work-folder.js';
+
+interface IResult {
+	changedFiles: string[];
+	hasChange: boolean;
+	remoteVersion?: string;
+}
+
+interface IDetectOptions {
+	forcePrivate?: boolean;
+}
+
+export async function executeChangeDetect(pm: IPackageManager, options: IDetectOptions): Promise<IResult> {
+	const packageJson = await pm.loadPackageJson();
+	logger.debug('修改检测 | 包名: %s', packageJson.name);
+	if (!packageJson.name) {
+		throw new Error(`${pm.projectPath}/package.json 中缺少 name 字段`);
+	}
+
+	const cache = await pm.createCacheHandler();
+
+	const p = new PathEnvironment();
+	p.add(resolve(pm.projectPath, 'node_modules/.bin'));
+	p.add(resolve(process.argv0, '..'));
+	for (const l in process.env) {
+		if (l.startsWith('LC_')) {
+			delete process.env[l];
+		}
+	}
+
+	if (packageJson.private && !options.forcePrivate) {
+		logger.debug('检测到私有包，禁止运行');
+		return { changedFiles: [], hasChange: false };
+	}
+
+	const remotePackage = await cache.fetchVersion(packageJson.name, distTagInput);
+	logger.debug(' -> npm 远程版本 = %s', remotePackage?.version);
+	logger.debug(' -> package.json 本地版本 = %s', packageJson.version);
+
+	if (!remotePackage || gt(packageJson.version, remotePackage.version)) {
+		logger.debug('本地版本 (%s) 已经大于远程版本 (%s)，无需进一步检测', packageJson.version, remotePackage?.version);
+		return { changedFiles: ['package.json'], hasChange: false, remoteVersion: remotePackage?.version };
+	}
+	logger.debug('本地版本 (%s) 小于或等于远程版本 (%s)，尝试检测更改...', packageJson.version, remotePackage.version);
+
+	const tarball = await cache.downloadTarball(packageJson.name, distTagInput);
+
+	const tempFolder = new TempWorkingFolder(pm.workspace, 'package-change-detect');
+	const workingRoot = tempFolder.resolve('working');
+	await workingRoot.unpack(tarball);
+	await makePackageJsonOrderConsistence(workingRoot.path);
+
+	const gitrepo = new GitWorkingTree(workingRoot.path);
+	await gitrepo.init();
+
+	const pack = await pm.pack(tempFolder.joinpath('local-pack.tgz'));
+	logger.verbose('  --> %s', pack);
+
+	await workingRoot.unpack(pack);
+	logger.verbose('  unpacked successfully');
+
+	await makePackageJsonOrderConsistence(workingRoot.path);
+
+	const changedFiles = await gitrepo.commitChanges();
+	logger.verbose`  changed files: list<${changedFiles}>`;
+
+	return { changedFiles, hasChange: changedFiles.length > 0, remoteVersion: remotePackage.version };
+}

package/src/common/shared-jobs/publish-package-version-job.ts

@@ -0,0 +1,46 @@
+import { logger } from '@idlebox/logger';
+import { exists } from '@idlebox/node';
+import { copyFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import type { IPackageManager } from '../package-manager/package-manager.js';
+import { TempWorkingFolder } from '../temp-work-folder.js';
+
+export const PUBLISH_PACKAGE_METACACHE_KEY = 'published-package';
+
+// interface StateCache {
+// 	id: string;
+// 	version: string;
+// 	size: number;
+// 	unpackedSize: number;
+// 	shasum: string;
+// 	entryCount: number;
+// }
+
+export async function publishPackageVersion(pm: IPackageManager) {
+	const wd = new TempWorkingFolder(pm.workspace, 'publish');
+	logger.debug('临时目录: %s', wd.path);
+	await wd.mkdir();
+
+	const packFile = await pm.pack(wd.path);
+	logger.debug('    -> %s', packFile);
+
+	const publish_rc = pm.workspace.getNpmRCPath(true);
+	const default_rc = pm.workspace.getNpmRCPath(false);
+	if (await exists(publish_rc)) {
+		logger.debug('找到配置文件: %s', publish_rc);
+		await copyFile(publish_rc, wd.joinpath('.npmrc'));
+	} else if (await exists(default_rc)) {
+		logger.debug('找到配置文件: %s', default_rc);
+		await copyFile(default_rc, wd.joinpath('.npmrc'));
+	} else {
+		logger.debug('没有找到配置文件.');
+	}
+
+	await copyFile(resolve(pm.projectPath, 'package.json'), wd.joinpath('package.json'));
+
+	await pm.uploadTarball(packFile, wd.path);
+
+	const pkg = await pm.loadPackageJson();
+	const cache = await pm.createCacheHandler();
+	await cache.deleteMetadata(pkg.name);
+}

package/src/common/taball/decompress.ts

@@ -0,0 +1,41 @@
+import { convertCatchedError } from '@idlebox/common';
+import { logger } from '@idlebox/logger';
+import { unlinkSync } from 'node:fs';
+import tgz from 'targz';
+
+const packageFolder = /^package\//;
+
+export async function decompressPack(src: string, dest: string) {
+	logger.debug(`解压文件: ${src}\n\u3000\u3000目录: ${dest}`);
+	await new Promise<void>((resolve, reject) => {
+		tgz.decompress(
+			{
+				src,
+				dest,
+				tar: {
+					ignore(_, header) {
+						return !header || !header.name;
+					},
+					map(header) {
+						if (packageFolder.test(header.name)) {
+							header.name = header.name.replace(packageFolder, '');
+						} else {
+							header.name = '';
+						}
+						return header;
+					},
+				},
+			},
+			(e) => {
+				if (e) {
+					console.error(convertCatchedError(e).stack);
+					unlinkSync(src);
+					reject(e);
+				} else {
+					resolve();
+				}
+			},
+		);
+	});
+	logger.debug('解压完成');
+}

package/src/common/taball/file-download.ts

@@ -0,0 +1,166 @@
+import { sleep } from '@idlebox/common';
+import { logger } from '@idlebox/logger';
+import { exists, streamPromise } from '@idlebox/node';
+import { createWriteStream } from 'node:fs';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import type { IncomingHttpHeaders, IncomingMessage, OutgoingHttpHeaders } from 'node:http';
+import { get } from 'node:https';
+import { dirname } from 'node:path';
+import type { Readable } from 'node:stream';
+import { createBrotliDecompress, createGunzip, createInflate } from 'node:zlib';
+
+interface IMetaInfo {
+	headers: IncomingHttpHeaders;
+	url: string;
+}
+
+export async function downloadFileCached(url: string, file: string) {
+	const metadata = `${file}.meta.json`;
+	logger.debug`下载文件:\n    地址: long<${url}>\n    保存到: long<${file}>`;
+	let meta: IMetaInfo | undefined;
+	if (await exists(metadata)) {
+		try {
+			meta = JSON.parse(await readFile(metadata, 'utf-8'));
+		} catch {}
+
+		if (meta?.url === url) {
+			logger.log('     -> 已经下载');
+			return file;
+		}
+	}
+	const response = await http_stream(url);
+
+	await mkdir(dirname(file), { recursive: true });
+	const writeOut = createWriteStream(`${file}.downloading`);
+	await streamPromise(response.stream.pipe(writeOut));
+
+	meta = { headers: response.headers, url };
+	await writeFile(metadata, JSON.stringify(meta), 'utf-8');
+
+	await rename(`${file}.downloading`, file);
+	logger.log('     -> 下载完成');
+
+	return file;
+}
+
+class RedirectError extends Error {
+	constructor(
+		url: string,
+		public readonly location: string,
+		public readonly code: number,
+	) {
+		super(`Request ${url} - Redirect to "${location}" with code ${code}`);
+	}
+
+	static is(obj: any): obj is RedirectError {
+		return obj instanceof RedirectError;
+	}
+}
+
+export class HttpError extends Error {
+	constructor(
+		public readonly url: string,
+		public readonly code: number,
+		msg: string,
+	) {
+		super(`Request ${url} - Server responded with ${code}: ${msg}`);
+	}
+
+	static is(obj: any): obj is HttpError {
+		return obj instanceof HttpError;
+	}
+}
+
+type IStream = { stream: Readable };
+export type INormalizedResponse = Omit<IncomingMessage, keyof Readable> & IStream;
+
+async function http_stream(url: string, headers?: OutgoingHttpHeaders): Promise<INormalizedResponse> {
+	let try_remain = 3;
+	let redirect_cnt = 0;
+	while (try_remain-- > 0) {
+		try {
+			return await send_request(url, headers || {});
+		} catch (e: unknown) {
+			if (RedirectError.is(e)) {
+				redirect_cnt++;
+				if (redirect_cnt > 8) {
+					throw new HttpError(url, 0, '重定向次数过多');
+				}
+
+				logger.debug(`[http] 重定向到 ${e.location}`);
+				url = e.location;
+				try_remain++;
+				continue;
+			}
+
+			logger.error('获取 %s 失败 [剩余尝试次数 %s]', url, try_remain);
+			if (try_remain === 0) throw e;
+
+			await sleep(2000);
+		}
+	}
+	throw new Error('不可能的错误');
+}
+
+function send_request(url: string, headers: OutgoingHttpHeaders): Promise<any> {
+	headers['Accept-Encoding'] = 'br,gzip,deflate';
+	return new Promise<any>((resolve, reject) => {
+		logger.debug(`[http] 请求 ${url}`);
+
+		const request = get(url, { headers }, (response) => {
+			logger.debug(
+				`[http] 响应 ${response.statusCode} [encoding: ${response.headers['content-encoding']}][${response.headers['content-length']} bytes]`,
+			);
+			if (response.statusCode === 200) {
+				const bytes = Number.parseInt(response.headers['content-length'] ?? '--');
+
+				if (bytes > 5 * 1024 * 1024 && process.stderr.isTTY) {
+					let downloaded = 0;
+					response.on('data', (bs) => {
+						downloaded += bs.length;
+						process.stderr.write(
+							`\x1B[2mdownload: ${downloaded} of ${bytes} bytes (${Math.round((downloaded / bytes) * 100)}%)\x1B[0m\r`,
+						);
+					});
+					response.on('end', () => {
+						process.stderr.write('\x1B[K');
+					});
+				}
+
+				let stream: Readable;
+				switch (response.headers['content-encoding']) {
+					case 'br':
+						stream = response.pipe(createBrotliDecompress());
+						break;
+					// Or, just use zlib.createUnzip() to handle both of the following cases:
+					case 'gzip':
+						stream = response.pipe(createGunzip());
+						break;
+					case 'deflate':
+						stream = response.pipe(createInflate());
+						break;
+					default:
+						stream = response;
+						break;
+				}
+				resolve(Object.assign(response, { stream }));
+			} else if (
+				(response.statusCode === 302 ||
+					response.statusCode === 301 ||
+					response.statusCode === 303 ||
+					response.statusCode === 307 ||
+					response.statusCode === 308) &&
+				response.headers.location
+			) {
+				reject(new RedirectError(url, response.headers.location, response.statusCode));
+			} else {
+				reject(new HttpError(url, response.statusCode as number, response.statusMessage as string));
+			}
+		});
+
+		request.on('error', (err) => {
+			reject(err);
+		});
+		request.end();
+	});
+}

package/src/common/temp-work-folder.ts

@@ -0,0 +1,80 @@
+import type { MonorepoWorkspace } from '@build-script/monorepo-lib';
+import { registerGlobalLifecycle } from '@idlebox/common';
+import { writeJsonFile } from '@idlebox/json-edit';
+import { logger } from '@idlebox/logger';
+import { emptyDir } from '@idlebox/node';
+import { randomBytes } from 'node:crypto';
+import { rmSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { isDebugMode } from './functions/cli.js';
+import { decompressPack } from './taball/decompress.js';
+
+export class TempWorkingFolder {
+	public readonly path: string;
+	private _exists = false;
+
+	constructor(
+		private readonly workspace: MonorepoWorkspace,
+		name: string,
+		__internal_isChild = false,
+	) {
+		if (!__internal_isChild) {
+			registerGlobalLifecycle(this);
+			name += `-${randomBytes(6).toString('hex')}`;
+		}
+		this.path = resolve(workspace.temp, name);
+	}
+
+	resolve(p0: string, ...paths: string[]) {
+		return new TempWorkingFolder(this.workspace, this.joinpath(p0, ...paths), true);
+	}
+
+	joinpath(p0: string, ...paths: string[]) {
+		const r = resolve(this.path, p0, ...paths);
+		if (r.startsWith(this.path)) {
+			return r;
+		}
+		throw new Error(`路径不在临时目录内: ${r}`);
+	}
+
+	async mkdir() {
+		logger.debug('临时工作目录: %s', this.path);
+		await mkdir(this.path, { recursive: true });
+		this._exists = true;
+	}
+
+	get exists() {
+		return this._exists;
+	}
+
+	async createPackage(name: string, type: 'module' | 'commonjs', version = '0.0.0') {
+		const packageJson = {
+			name,
+			version,
+			type,
+			dependencies: {},
+		};
+		const file = resolve(this.path, 'package.json');
+		const data = JSON.stringify(packageJson, null, 4);
+		await writeJsonFile(file, data);
+
+		const tempDir = resolve(this.path, 'node_modules');
+		await emptyDir(tempDir);
+
+		return packageJson;
+	}
+
+	unpack(tarball: string, dest = '.') {
+		return decompressPack(tarball, resolve(this.path, dest));
+	}
+
+	dispose() {
+		if (!isDebugMode) {
+			logger.debug('  * 删除临时目录: %s', this.path);
+			rmSync(this.path, { force: true, recursive: true });
+		} else {
+			logger.debug('  * 由于是调试模式，不删除临时文件夹: %s', this.path);
+		}
+	}
+}

package/src/common/version.generated.ts

@@ -0,0 +1,18 @@
+/* eslint-disable */
+// @ts-ignore
+// biome-ignore-all lint
+// biome-ignore-all assist
+// biome-ignore-all syntax
+/******************************************************************************
+ *  GENERATED FILE, DO NOT MODIFY
+ *  这是生成的文件，千万不要修改
+ * 
+ * @build-script/codegen 1.0.0 - The Simple Code Generater
+ * https://github.com/GongT/baobao
+ * 
+ ******************************************************************************/
+
+export const self_package_version = "0.0.1";
+export const self_package_name = "@build-script/package-tools";
+export const self_package_repository = "undefined";
+

package/src/common/version.generator.ts

@@ -0,0 +1,15 @@
+import type { FileBuilder, IOutputShim } from '@build-script/heft-plugin-base';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+export function generate(builder: FileBuilder, logger: IOutputShim) {
+	const pkgFile = path.resolve(__dirname, '../../package.json');
+	const pkg = JSON.parse(fs.readFileSync(pkgFile, 'utf-8'));
+
+	logger.log(`package info = ${pkg.name} @ ${pkg.version}`);
+
+	return `export const self_package_version = "${pkg.version}";
+export const self_package_name = "${pkg.name}";
+export const self_package_repository = "${pkg.repository}";
+`;
+}

package/src/global.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import stream = require('node:stream');
+
+export type Callback = (err?: Error | null) => any;
+
+export interface Pack extends stream.Readable {
+	/**
+	 * To create a pack stream use tar.pack() and call pack.entry(header, [callback]) to add tar entries.
+	 */
+	entry(headers: Headers, callback?: Callback): stream.Writable;
+	entry(headers: Headers, buffer?: string | Buffer, callback?: Callback): stream.Writable;
+	finalize(): void;
+}
+
+declare module 'make-fetch-happen/make-fetch-happen/lib/cache/key.js' {
+	export function cacheKey(key: string): string;
+}