@mpis/run 0.0.1

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@mpis/run",
+  "type": "module",
+  "version": "0.0.1",
+  "keywords": [],
+  "bin": {
+    "run": "./loader/bin.devel.js",
+    "mpis-run": "./loader/bin.devel.js"
+  },
+  "exports": {
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "execa": "^9.6.0",
+    "source-map-support": "^0.5.21",
+    "split-cmd": "^1.1.0",
+    "@build-script/rushstack-config-loader": "^0.0.20",
+    "@idlebox/args": "^0.0.9",
+    "@idlebox/node": "^1.4.7",
+    "@idlebox/logger": "^0.0.1",
+    "@idlebox/common": "^1.4.14",
+    "@mpis/client": "^0.0.1",
+    "@mpis/server": "^0.0.1",
+    "@mpis/shared": "^0.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.14",
+    "@build-script/single-dog-asset": "^1.0.35",
+    "@idlebox/esbuild-executer": "^0.0.2",
+    "@internal/local-rig": "^1.0.1"
+  },
+  "decoupledDependencies": "*",
+  "scripts": {
+    "build": "node loader/bin.devel.js build",
+    "watch": "node loader/bin.devel.js watch",
+    "clean": "node loader/bin.devel.js clean",
+    "prepublishHook": "internal-prepublish-hook",
+    "lint": "internal-lint"
+  }
+}

package/src/autoindex.ts

@@ -0,0 +1,18 @@
+// DO NOT EDIT THIS FILE
+// @ts-ignore
+/* eslint-disable */
+
+/* common/args.ts */
+	// Identifiers
+	export { printUsage } from "./common/args.js";
+/* common/paths.ts */
+	// Identifiers
+	export { projectRoot } from "./common/paths.js";
+	export { selfRoot } from "./common/paths.js";
+/* common/config-file.ts */
+	// Identifiers
+	export type { ICommand } from "./common/config-file.js";
+	export type { IConfigFile } from "./common/config-file.js";
+	export { loadConfigFile } from "./common/config-file.js";
+/* bin.ts */
+	// Identifiers

package/src/bin.ts

@@ -0,0 +1,268 @@
+import { humanDate, prettyFormatError, registerGlobalLifecycle, toDisposable } from '@idlebox/common';
+import { logger } from '@idlebox/logger';
+import { registerNodejsExitHandler } from '@idlebox/node';
+import { channelClient } from '@mpis/client';
+import { CompileError, ModeKind, ProcessIPCClient, WorkersManager } from '@mpis/server';
+import { rmSync } from 'node:fs';
+import { context, parseCliArgs } from './common/args.js';
+import { loadConfigFile } from './common/config-file.js';
+import { projectRoot } from './common/paths.js';
+import { initializeStdin, registerCommand } from './common/stdin.js';
+
+registerNodejsExitHandler();
+
+parseCliArgs();
+
+const start = Date.now();
+registerGlobalLifecycle(
+	toDisposable(() => {
+		logger.info`Operation completed in ${humanDate.delta(Date.now() - start)} (${process.exitCode ? 'failed' : 'success'}).`;
+	}),
+);
+
+registerCommand({
+	name: ['status', 's'],
+	description: '显示当前状态',
+	callback: () => reprintWatchModeError(),
+});
+
+process.title = `MpisRun`;
+
+logger.info`Running command "${context.command}" in ${projectRoot}`;
+
+const defaultNoClear = logger.debug.isEnabled;
+let workersManager: WorkersManager;
+
+const config = loadConfigFile(context.watchMode);
+logger.verbose`loaded config file: ${config}`;
+const errors = new Map<ProcessIPCClient, Error | null>();
+
+switch (context.command) {
+	case 'clean':
+		executeClean();
+		break;
+	case 'build':
+		{
+			if (context.withCleanup) executeClean();
+
+			await executeBuild();
+		}
+		break;
+	case 'watch':
+		initializeStdin();
+		await executeBuild();
+		break;
+}
+
+// channelClient.displayName = `MpisRun`;
+
+async function executeBuild() {
+	workersManager = new WorkersManager(context.watchMode ? ModeKind.Watch : ModeKind.Build);
+
+	initializeWorkers();
+
+	workersManager.onTerminate((w) => {
+		if (!ProcessIPCClient.is(w)) {
+			logger.fatal`worker "${w._id}" is not a ProcessIPCClient, this is a bug.`;
+			return;
+		}
+
+		const times = `(+${humanDate.delta(w.time.executeEnd! - w.time.executeStart!)})`;
+
+		if (context.watchMode) {
+			printFailedRunError(w, `unexpected exit in watch mode ${times}`);
+		} else if (!w.isSuccess) {
+			printFailedRunError(w, `failed to execute ${times}`);
+		} else {
+			logger.success`"${w._id}" successfully finished ${times}.`;
+		}
+	});
+
+	workersManager.finalize();
+
+	channelClient.start();
+
+	if (context.breakMode) {
+		logger.warn`Break mode enabled, waiting for input command...`;
+		addDebugCommand();
+		return;
+	}
+	logger.verbose`Workers initialized, starting execution...`;
+	await workersManager.startup();
+
+	reprintWatchModeError();
+}
+
+function executeClean() {
+	for (const folder of config.clean) {
+		logger.log` * removing folder: ${folder}`;
+		rmSync(folder, { recursive: true, force: true });
+	}
+	logger.success`Cleaned up ${config.clean.length} folders.`;
+}
+
+function initializeWorkers() {
+	let last: ProcessIPCClient | undefined;
+	for (const title of config.buildTitles) {
+		const cmds = config.build.get(title);
+		if (!cmds) throw logger.fatal`program state error, no build command "${title}"`;
+
+		if (!cmds.env['DEBUG']) cmds.env['DEBUG'] = '';
+		if (!cmds.env['DEBUG_LEVEL']) cmds.env['DEBUG_LEVEL'] = '';
+		const worker = new ProcessIPCClient(title.replace(/\s+/g, ''), cmds.command, cmds.cwd, cmds.env);
+
+		for (const path of config.additionalPaths) {
+			worker.pathvar.add(path);
+		}
+
+		const cmd0 = typeof cmds.command === 'string' ? cmds.command.split(' ')[0] : cmds.command[0];
+		worker.displayTitle = `run:${cmd0}`;
+
+		workersManager.addWorker(worker, last ? [last._id] : []);
+
+		let nodeFirstTime = true;
+		worker.onFailure((e) => {
+			errors.set(worker, e);
+			reprintWatchModeError(nodeFirstTime);
+			nodeFirstTime = false;
+			sendStatus();
+		});
+		worker.onSuccess(() => {
+			errors.set(worker, null);
+			if (nodeFirstTime) {
+				nodeFirstTime = false;
+			} else {
+				reprintWatchModeError();
+			}
+			sendStatus();
+		});
+
+		last = worker;
+	}
+}
+
+function printFailedRunError(worker: ProcessIPCClient, message: string) {
+	if (context.watchMode) process.stderr.write('\x1Bc');
+
+	const text = worker.outputStream.toString().trimEnd();
+
+	if (text) {
+		console.error(
+			'\n\x1B[48;5;1m%s\r    \x1B[0;38;5;9;1m  %s  \x1B[0m',
+			' '.repeat(process.stderr.columns || 80),
+			`below is output of ${worker._id}`,
+		);
+		console.error(text);
+
+		console.error(
+			'\x1B[48;5;1m%s\r    \x1B[0;38;5;9;1m  %s  \x1B[0m\n',
+			' '.repeat(process.stderr.columns || 80),
+			`ending output of ${worker._id}`,
+		);
+	} else {
+		console.error(
+			'\n\x1B[48;5;1m%s\r    \x1B[0;38;5;9;1m  %s  \x1B[0m',
+			' '.repeat(process.stderr.columns || 80),
+			`no output from ${worker._id}`,
+		);
+	}
+
+	console.error(workersManager.formatDebugGraph());
+	logger.fatal`"${worker._id}" ${message}`;
+}
+
+function reprintWatchModeError(noClear?: boolean) {
+	if (context.watchMode) {
+		if (!noClear && !defaultNoClear) process.stderr.write('\x1Bc');
+	}
+	console.error(workersManager.formatDebugList());
+	printAllErrors();
+}
+
+function addDebugCommand() {
+	registerCommand({
+		name: ['continue', 'c'],
+		description: '开始执行',
+		callback: () => {
+			workersManager.startup();
+		},
+	});
+	registerCommand({
+		name: ['debug'],
+		description: '切换调试模式（仅在启动前有效）',
+		callback: (text: string) => {
+			const [_, index, on_off] = text.split(/\s+/);
+			const list: ProcessIPCClient[] = workersManager.allWorkers as ProcessIPCClient[];
+			const worker = list[Number(index)];
+			if (!worker) {
+				logger.error`worker index out of range: ${index}`;
+				return;
+			}
+			if (on_off === 'on') {
+				worker.env['DEBUG'] = '*,-executer:*,-dispose:*';
+				worker.env['DEBUG_LEVEL'] = 'verbose';
+				logger.success`debug mode enabled for worker "${worker._id}"`;
+			} else if (on_off === 'off') {
+				worker.env['DEBUG'] = '';
+				worker.env['DEBUG_LEVEL'] = '';
+				logger.success`debug mode disabled for worker "${worker._id}"`;
+			} else {
+				logger.error`invalid argument: ${text}`;
+			}
+		},
+	});
+	// registerCommand({
+	// 	name: ['print', 'p'],
+	// 	description: '显示命令执行输出',
+	// 	callback: () => {
+	// 	},
+	// });
+}
+
+function sendStatus() {
+	const noError = errors.values().every((e) => !e);
+	if (noError) {
+		channelClient.success(`All workers completed successfully.`);
+	} else {
+		const errorCnt = errors.values().filter((e) => !!e);
+		channelClient.failed(`${errorCnt} (of ${workersManager.size}) workers error.`, formatAllErrors());
+	}
+}
+
+function formatAllErrors() {
+	const lines: string[] = [];
+	const colorEnabled = logger.colorEnabled;
+	let index = 0;
+	for (const [worker, error] of errors) {
+		if (error === null) continue;
+
+		index++;
+
+		let tag = '';
+		if (error.name !== 'Error') {
+			tag = ` (${error.name})`;
+		}
+		const banner = colorEnabled ? `\x1B[48;5;9m ERROR ${index} \x1B[0m` : `ERROR ${index}`;
+		lines.push(`\n${banner}${tag} ${worker._id}`);
+		if (error instanceof CompileError) {
+			lines.push(error.toString());
+		} else if (error instanceof Error) {
+			lines.push(prettyFormatError(error));
+		} else {
+			lines.push(`can not handle error: ${error}`);
+		}
+		lines.push(`\n${banner} ${worker._id}`);
+	}
+	return lines.join('\n');
+}
+
+function printAllErrors() {
+	const numFailed = [...errors.values().filter((e) => !!e)].length;
+	if (numFailed !== 0) {
+		console.error(formatAllErrors());
+
+		logger.error(`💥 ${numFailed} of ${workersManager.size} worker failed`);
+	} else {
+		logger.success(`✅ no error in ${workersManager.size} workers`);
+	}
+}

package/src/common/args.ts

@@ -0,0 +1,67 @@
+import { argv } from '@idlebox/args/default';
+import { createRootLogger, EnableLogLevel, logger } from '@idlebox/logger';
+
+export function printUsage() {
+	console.log('Usage: my-cli <command>');
+	console.log();
+	console.log('Commands:');
+	console.log('  build   run build');
+	console.log('  watch   start watch mode');
+	console.log('  clean   cleanup the project');
+	console.log('  init    create config/commands.json');
+}
+
+export function parseCliArgs() {
+	const debugLevel = argv.flag(['-d', '--debug']);
+
+	const debugMode = debugLevel > 0;
+	const verboseMode = debugLevel > 1;
+
+	let level = EnableLogLevel.log;
+	if (verboseMode) {
+		level = EnableLogLevel.verbose;
+	} else if (debugMode) {
+		level = EnableLogLevel.debug;
+	}
+
+	createRootLogger('', level);
+
+	const command = argv.command(['build', 'watch', 'clean', 'init']);
+	if (!command) {
+		printUsage();
+		throw logger.fatal`No command provided. Please specify a command to run.`;
+	}
+
+	const watchMode = command.value === 'watch';
+	const buildMode = command.value === 'build';
+
+	let breakMode = false;
+	if (watchMode) {
+		breakMode = argv.flag('--break') > 0;
+	}
+
+	let withCleanup = false;
+	if (buildMode) {
+		withCleanup = argv.flag('--clean') > 0;
+	}
+
+	if (argv.unused().length > 0) {
+		throw logger.fatal`Unknown arguments: ${argv.unused().join(' ')}`;
+	}
+
+	const r = {
+		command: command.value,
+		debugMode,
+		verboseMode,
+		watchMode,
+		buildMode,
+		breakMode,
+		withCleanup,
+	};
+
+	context = r;
+
+	return r;
+}
+
+export let context: Readonly<ReturnType<typeof parseCliArgs>>;

package/src/common/config-file.ts

@@ -0,0 +1,198 @@
+import { ProjectConfig } from '@build-script/rushstack-config-loader';
+import { logger } from '@idlebox/logger';
+import { findUpUntilSync } from '@idlebox/node';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { projectRoot, selfRoot } from './paths.js';
+
+interface IPackageBinary {
+	package: string;
+	binary?: string;
+	arguments?: readonly string[];
+}
+
+interface ICommandInput {
+	title?: string;
+	command: string | readonly string[] | IPackageBinary;
+	watch?: string | readonly string[];
+	cwd?: string;
+	env?: Record<string, string>;
+}
+interface IConfigFileInput {
+	build: (string | ICommandInput)[];
+	commands: Record<string, ICommandInput>;
+	clean: string[];
+}
+
+export interface ICommand {
+	title: string;
+	command: string | readonly string[];
+	cwd: string;
+	env: Record<string, string>;
+}
+export interface IConfigFile {
+	buildTitles: readonly string[];
+	build: ReadonlyMap<string, ICommand>;
+	clean: readonly string[];
+	additionalPaths: readonly string[];
+}
+
+function watchModeCmd(
+	command: string | readonly string[],
+	watch?: string | readonly string[],
+	watchMode?: boolean,
+): string | readonly string[] {
+	if (!watchMode) {
+		return command;
+	}
+
+	if (typeof command === 'string') {
+		if (!watch) watch = '-w';
+
+		return `${command} ${watch}`;
+	} else {
+		if (!watch) watch = ['-w'];
+
+		return [...command, ...watch];
+	}
+}
+
+export function loadConfigFile(watchMode: boolean): IConfigFile {
+	const config = new ProjectConfig(projectRoot, undefined, logger);
+	const schemaFile = resolve(selfRoot, 'commands.schema.json');
+
+	const configFile = config.getJsonConfigInfo('commands');
+	logger.debug`using config file long<${configFile.effective}>`;
+
+	const input: IConfigFileInput = config.loadBothJson('commands', schemaFile, {
+		arrayMerge(target, _source) {
+			return target;
+		},
+	});
+
+	const buildMap = new Map<string, ICommand>();
+	const buildTitles: string[] = [];
+	function set(cmd: ICommand) {
+		if (buildMap.has(cmd.title)) {
+			throw new Error(`duplicate command "${cmd.title}", rename it before continue`);
+		}
+		buildMap.set(cmd.title, cmd);
+		buildTitles.push(cmd.title);
+	}
+
+	for (let item of input.build) {
+		if (typeof item === 'string') {
+			item = input.commands[item];
+			if (!item) {
+				logger.fatal`command "${item}" not found in commands`;
+			}
+		}
+
+		const cmd = item.command;
+		if (Array.isArray(cmd)) {
+			const copy = cmd.slice();
+			resolveCommandIsFile(config, copy);
+			set({
+				title: item.title ?? guessTitle(cmd),
+				command: watchModeCmd(copy, item.watch, watchMode),
+				cwd: resolve(projectRoot, item.cwd || '.'),
+				env: item.env ?? {},
+			});
+		} else if (typeof cmd === 'object' && 'package' in cmd) {
+			const obj = parsePackagedBinary(config, item, watchMode);
+			set(obj);
+		} else {
+			throw TypeError(`Invalid command type: ${typeof cmd}. Expected string or array or object.`);
+		}
+	}
+
+	const additionalPaths: string[] = [];
+	if (config.rigConfig.rigFound) {
+		const nmPath = findUpUntilSync({ file: 'node_modules', from: config.rigConfig.getResolvedProfileFolder() });
+		if (!nmPath) {
+			throw new Error(
+				`Failed to find "node_modules" folder in rig profile "${config.rigConfig.getResolvedProfileFolder()}".`,
+			);
+		}
+		additionalPaths.push(resolve(nmPath, '.bin'));
+	}
+
+	const clean = [];
+	for (const item of input.clean) {
+		const abs = resolve(projectRoot, item);
+		if (!abs.startsWith(projectRoot)) {
+			throw new Error(`invalid clean path "${item}", out of project "${projectRoot}"`);
+		}
+		clean.push(abs);
+	}
+
+	return {
+		buildTitles,
+		build: buildMap,
+		clean,
+		additionalPaths: additionalPaths.toReversed(),
+	};
+}
+
+function guessTitle(command: string | readonly string[]): string {
+	if (typeof command === 'string') {
+		return command.split(' ')[0];
+	}
+	if (Array.isArray(command)) {
+		return command[0];
+	}
+
+	throw new Error(`Invalid command: ${Array.isArray(command) ? command.join(' ') : command}.`);
+}
+
+function parsePackagedBinary(config: ProjectConfig, item: ICommandInput, watchMode: boolean): ICommand {
+	const cmd = item.command as IPackageBinary;
+
+	const pkgJsonPath = fileURLToPath(config.resolve(`${cmd.package}/package.json`));
+	let title = item.title;
+	if (!title) {
+		title = cmd.package.split('/').pop();
+		if (cmd.binary && cmd.binary !== title) {
+			title += `:${cmd.binary}`;
+		}
+	}
+
+	const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+	const type1 = typeof pkg.bin === 'string';
+	const type2 = !!cmd.binary;
+	if (type1 && type2) {
+		throw new Error(`"${pkgJsonPath}" "bin" field is string, can not specify "binary" in "commands.json".`);
+	} else if (!type1 && !type2) {
+		throw new Error(`"${pkgJsonPath}" "bin" field is not string, must specify "binary" in "commands.json".`);
+	}
+
+	const binVal = type1 ? pkg.bin : pkg.bin[cmd.binary as string];
+	const binPath = resolve(pkgJsonPath, '..', binVal);
+
+	return {
+		title: title!,
+		command: watchModeCmd([process.execPath, binPath, ...(cmd.arguments ?? [])], item.watch, watchMode),
+		cwd: resolve(projectRoot, item.cwd || '.'),
+		env: item.env ?? {},
+	};
+}
+
+/**
+ * 如果command第一个元素看似是一个文件，则解析成绝对路径并添加node前缀。
+ * 直接修改command数组。
+ *
+ * @param config
+ * @param command
+ */
+function resolveCommandIsFile(config: ProjectConfig, command: string[]) {
+	if (!command[0].endsWith('.ts')) return;
+
+	const r = config.getFileInfo(command[0]);
+
+	if (!r.effective) {
+		return; // will error later
+	}
+
+	command.splice(0, 1, process.execPath, r.effective);
+}

package/src/common/paths.ts

@@ -0,0 +1,15 @@
+import { findUpUntilSync } from '@idlebox/node';
+import { dirname } from 'node:path';
+
+const root = findUpUntilSync({ file: 'package.json', from: process.cwd() });
+if (!root) {
+	throw new Error('Could not find project root directory');
+}
+export const projectRoot = dirname(root);
+
+const self = findUpUntilSync({ file: 'package.json', from: import.meta.dirname });
+if (!self) {
+	throw new Error('Could not find self directory');
+}
+export const selfRoot = dirname(self);
+

package/src/common/stdin.ts

@@ -0,0 +1,65 @@
+import { logger } from '@idlebox/logger';
+import { projectRoot } from './paths.js';
+
+interface ICommand {
+	name: string | readonly string[];
+	description: string;
+	callback(input: string): void;
+}
+
+const stdinCommands: ICommand[] = [];
+export function registerCommand(command: ICommand) {
+	stdinCommands.push(command);
+}
+
+registerCommand({
+	name: 'help',
+	description: '显示帮助信息',
+	callback: printHelp,
+});
+
+export function initializeStdin() {
+	if (!process.stdin.isTTY) {
+		return;
+	}
+	process.stdin.setEncoding('utf8');
+	process.stdin.on('data', (data: string) => {
+		const text = data.trim();
+		if (!text) return;
+
+		logger.debug`recv: ${text}`;
+
+		const firstWord = text.split(/\s/, 1)[0];
+
+		for (const command of stdinCommands) {
+			let match = false;
+			if (Array.isArray(command.name)) {
+				match = command.name.includes(firstWord);
+			} else {
+				match = command.name === firstWord;
+			}
+			if (match) {
+				command.callback(text);
+				console.log('');
+				return;
+			}
+		}
+
+		logger.warn`Unknown command: ${text} [type "help"]`;
+		console.log('');
+	});
+	process.stdin.on('end', () => {
+		console.log('End of input stream');
+	});
+}
+
+function printHelp() {
+	console.log('This is `mpis-run watch`');
+	console.log(`working directory: ${projectRoot}`);
+
+	console.log('Available commands:');
+	for (const command of stdinCommands) {
+		const n = Array.isArray(command.name) ? command.name.join(', ') : command.name;
+		console.log(`  - ${n}: ${command.description}`);
+	}
+}

package/src/tsconfig.json

@@ -0,0 +1,9 @@
+{
+	"extends": "@internal/local-rig/profiles/default/tsconfig.json",
+	"compilerOptions": {
+		"typeRoots": ["../node_modules/@types", "../node_modules"],
+		"outDir": "../lib",
+		"rootDir": "./",
+		"types": ["node"]
+	}
+}