@eggjs/bin 7.3.1 → 7.4.0-beta.10

package/README.md

@@ -1,8 +1,6 @@
 # @eggjs/bin
 
 [![NPM version][npm-image]][npm-url]
-[![build status][ci-image]][ci-url]
-[![Test coverage][codecov-image]][codecov-url]
 [![Known Vulnerabilities][snyk-image]][snyk-url]
 [![npm download][download-image]][download-url]
 [![Node.js Version][node-version-image]][node-version-url]
@@ -10,10 +8,6 @@
 
 [npm-image]: https://img.shields.io/npm/v/@eggjs/bin.svg?style=flat-square
 [npm-url]: https://npmjs.org/package/@eggjs/bin
-[ci-image]: https://github.com/eggjs/bin/actions/workflows/nodejs.yml/badge.svg
-[ci-url]: https://github.com/eggjs/bin/actions/workflows/nodejs.yml
-[codecov-image]: https://codecov.io/gh/eggjs/bin/branch/master/graph/badge.svg
-[codecov-url]: https://codecov.io/gh/eggjs/bin
 [snyk-image]: https://snyk.io/test/npm/@eggjs/bin/badge.svg?style=flat-square
 [snyk-url]: https://snyk.io/test/npm/@eggjs/bin
 [download-image]: https://img.shields.io/npm/dm/@eggjs/bin.svg?style=flat-square
@@ -95,12 +89,7 @@ Create `.vscode/launch.json` file:
       "request": "launch",
       "name": "Egg Debug",
       "runtimeExecutable": "npm",
-      "runtimeArgs": [
-        "run",
-        "dev",
-        "--",
-        "--inspect-brk"
-      ],
+      "runtimeArgs": ["run", "dev", "--", "--inspect-brk"],
       "console": "integratedTerminal",
       "restart": true,
       "autoAttachChildProcesses": true
@@ -110,12 +99,7 @@ Create `.vscode/launch.json` file:
       "request": "launch",
       "name": "Egg Test",
       "runtimeExecutable": "npm",
-      "runtimeArgs": [
-        "run",
-        "test-local",
-        "--",
-        "--inspect-brk"
-      ],
+      "runtimeArgs": ["run", "test-local", "--", "--inspect-brk"],
       "autoAttachChildProcesses": true
     }
   ]
@@ -190,10 +174,8 @@ You can pass any mocha argv.
 - `--prerequire` prerequire files for coverage instrument, you can use this options if load files slowly when call `mm.app` or `mm.cluster`
 - `--typescript` enable typescript support. If `true`, will auto add `.ts` extension and ignore `typings` and `d.ts`.
 - `--c8` c8 instruments passthrough. you can use this to overwrite egg-bin's default c8 instruments and add additional ones.
-  >
   > - egg-bin have some default instruments passed to c8 like `-r` and `--temp-directory`
   > - `egg-bin cov --c8="-r teamcity -r text" --c8-report=true`
-  >
 - also support all test params above.
 
 #### cov environment
@@ -214,7 +196,7 @@ See <https://oclif.io/docs/configuring_your_cli/>
 
 ## Contributors
 
-[![Contributors](https://contrib.rocks/image?repo=eggjs/bin)](https://github.com/eggjs/bin/graphs/contributors)
+[![Contributors](https://contrib.rocks/image?repo=eggjs/egg)](https://github.com/eggjs/egg/graphs/contributors)
 
 Made with [contributors-img](https://contrib.rocks).
 

package/dist/baseCommand.d.ts

@@ -0,0 +1,52 @@
+import { PackageEgg } from "./types.js";
+import { Command, Interfaces } from "@oclif/core";
+import { ForkOptions } from "node:child_process";
+
+//#region src/baseCommand.d.ts
+declare class ForkError extends Error {
+  code: number | null;
+  constructor(message: string, code: number | null);
+}
+interface ForkNodeOptions extends ForkOptions {
+  dryRun?: boolean;
+}
+type CustomFlags<T extends typeof Command> = Interfaces.InferredFlags<(typeof BaseCommand)['baseFlags'] & T['flags']>;
+type Args$1<T extends typeof Command> = Interfaces.InferredArgs<T['args']>;
+declare abstract class BaseCommand<T extends typeof Command> extends Command {
+  #private;
+  static enableJsonFlag: boolean;
+  static baseFlags: {
+    'dry-run': Interfaces.BooleanFlag<boolean>;
+    require: Interfaces.OptionFlag<string[] | undefined, Interfaces.CustomOptions>;
+    import: Interfaces.OptionFlag<string[] | undefined, Interfaces.CustomOptions>;
+    base: Interfaces.OptionFlag<string, Interfaces.CustomOptions>;
+    tscompiler: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+    typescript: Interfaces.BooleanFlag<boolean>;
+    ts: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+    javascript: Interfaces.BooleanFlag<boolean>;
+    declarations: Interfaces.BooleanFlag<boolean>;
+    inspect: Interfaces.BooleanFlag<boolean>;
+    'inspect-brk': Interfaces.BooleanFlag<boolean>;
+  };
+  protected flags: CustomFlags<T>;
+  protected args: Args$1<T>;
+  protected env: {
+    [key: string]: string | undefined;
+    TZ?: string;
+  };
+  protected pkg: Record<string, any>;
+  protected isESM: boolean;
+  protected pkgEgg: PackageEgg;
+  protected globalExecArgv: string[];
+  init(): Promise<void>;
+  protected catch(err: Error & {
+    exitCode?: number;
+  }): Promise<any>;
+  protected finally(_: Error | undefined): Promise<any>;
+  protected formatRequires(): Promise<string[]>;
+  protected formatImportModule(modulePath: string): string;
+  protected addNodeOptions(options: string): void;
+  protected forkNode(modulePath: string, forkArgs: string[], options?: ForkNodeOptions): Promise<void>;
+}
+//#endregion
+export { BaseCommand, ForkError, ForkNodeOptions };

package/dist/baseCommand.js

@@ -0,0 +1,288 @@
+import { getSourceDirname, hasTsConfig, readPackageJSON } from "./utils.js";
+import { debuglog } from "node:util";
+import path from "node:path";
+import os from "node:os";
+import { Command, Flags, Interfaces } from "@oclif/core";
+import { importResolve } from "@eggjs/utils";
+import { pathToFileURL } from "node:url";
+import { fork } from "node:child_process";
+import { runScript } from "runscript";
+
+//#region src/baseCommand.ts
+const debug = debuglog("egg-bin/baseCommand");
+const children = /* @__PURE__ */ new Set();
+let hadHook = false;
+function graceful(proc) {
+	children.add(proc);
+	/* c8 ignore else */
+	if (!hadHook) {
+		hadHook = true;
+		let signal;
+		[
+			"SIGINT",
+			"SIGQUIT",
+			"SIGTERM"
+		].forEach((event) => {
+			process.once(event, () => {
+				signal = event;
+				process.exit(0);
+			});
+		});
+		process.once("exit", (code) => {
+			for (const child of children) {
+				debug("process exit code: %o, kill child %o with %o", code, child.pid, signal);
+				child.kill(signal);
+			}
+		});
+	}
+}
+var ForkError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+	}
+};
+var BaseCommand = class extends Command {
+	static enableJsonFlag = false;
+	static baseFlags = {
+		"dry-run": Flags.boolean({
+			default: false,
+			helpGroup: "GLOBAL",
+			summary: "whether show full command script only",
+			char: "d"
+		}),
+		require: Flags.string({
+			helpGroup: "GLOBAL",
+			summary: "require the given module",
+			char: "r",
+			multiple: true
+		}),
+		import: Flags.string({
+			helpGroup: "GLOBAL",
+			summary: "import the given module, only work on ESM",
+			multiple: true
+		}),
+		base: Flags.string({
+			helpGroup: "GLOBAL",
+			summary: "directory of application",
+			aliases: ["baseDir"],
+			default: process.cwd()
+		}),
+		tscompiler: Flags.string({
+			helpGroup: "GLOBAL",
+			summary: "TypeScript compiler, like ts-node/register",
+			aliases: ["tsc"]
+		}),
+		typescript: Flags.boolean({
+			helpGroup: "GLOBAL",
+			description: "[default: true] use TypeScript to run the test",
+			allowNo: true
+		}),
+		ts: Flags.string({
+			helpGroup: "GLOBAL",
+			description: "shortcut for --typescript, e.g.: --ts=false",
+			options: ["true", "false"]
+		}),
+		javascript: Flags.boolean({
+			helpGroup: "GLOBAL",
+			description: "use JavaScript to run the test",
+			aliases: ["js"]
+		}),
+		declarations: Flags.boolean({
+			helpGroup: "GLOBAL",
+			description: "whether create typings, will add `--require egg-ts-helper/register`",
+			aliases: ["dts"]
+		}),
+		inspect: Flags.boolean({
+			helpGroup: "GLOBAL",
+			description: "Activate inspector"
+		}),
+		"inspect-brk": Flags.boolean({
+			helpGroup: "GLOBAL",
+			description: "Activate inspector and break at start of user script"
+		})
+	};
+	flags;
+	args;
+	env = { ...process.env };
+	pkg;
+	isESM;
+	pkgEgg;
+	globalExecArgv = [];
+	async init() {
+		await super.init();
+		debug("[init] raw args: %o, NODE_ENV: %o", this.argv, this.env.NODE_ENV);
+		const { args, flags } = await this.parse({
+			flags: this.ctor.flags,
+			baseFlags: super.ctor.baseFlags,
+			enableJsonFlag: this.ctor.enableJsonFlag,
+			args: this.ctor.args,
+			strict: this.ctor.strict
+		});
+		this.flags = flags;
+		this.args = args;
+		await this.#afterInit();
+	}
+	async #afterInit() {
+		const { args, flags } = this;
+		debug("before: args: %o, flags: %o", args, flags);
+		if (!path.isAbsolute(flags.base)) flags.base = path.join(process.cwd(), flags.base);
+		const pkg = await readPackageJSON(flags.base);
+		this.pkg = pkg;
+		this.pkgEgg = pkg.egg ?? {};
+		flags.tscompiler = flags.tscompiler ?? this.env.TS_COMPILER ?? this.pkgEgg.tscompiler;
+		let typescript = flags.typescript;
+		if (flags.ts === "true") typescript = true;
+		else if (flags.ts === "false") typescript = false;
+		if (typescript === void 0) {
+			if (this.env.EGG_TYPESCRIPT === "false") {
+				typescript = false;
+				debug("detect typescript=%o from EGG_TYPESCRIPT=%o", false, this.env.EGG_TYPESCRIPT);
+			} else if (this.env.EGG_TYPESCRIPT === "true") {
+				typescript = true;
+				debug("detect typescript=%o from EGG_TYPESCRIPT=%o", true, this.env.EGG_TYPESCRIPT);
+			} else if (typeof this.pkgEgg.typescript === "boolean") {
+				typescript = this.pkgEgg.typescript;
+				debug("detect typescript=%o from pkg.egg.typescript=%o", typescript, this.pkgEgg.typescript);
+			} else if (pkg.dependencies?.typescript) {
+				typescript = true;
+				debug("detect typescript=%o from pkg.dependencies.typescript=%o", true, pkg.dependencies.typescript);
+			} else if (pkg.devDependencies?.typescript) {
+				typescript = true;
+				debug("detect typescript=%o from pkg.devDependencies.typescript=%o", true, pkg.devDependencies.typescript);
+			} else if (await hasTsConfig(flags.base)) {
+				typescript = true;
+				debug("detect typescript=%o cause tsconfig.json exists", true);
+			} else if (flags.tscompiler) {
+				typescript = true;
+				debug("detect typescript=%o from --tscompiler=%o", true, flags.tscompiler);
+			}
+		}
+		flags.typescript = typescript;
+		let rootDir = path.dirname(getSourceDirname());
+		if (path.basename(rootDir) === "dist") rootDir = path.dirname(rootDir);
+		const findPaths = [flags.base, rootDir];
+		this.isESM = pkg.type === "module";
+		if (typescript) {
+			flags.tscompiler = flags.tscompiler ?? "ts-node/register";
+			const tsNodeRegister = importResolve(flags.tscompiler, { paths: findPaths });
+			flags.tscompiler = tsNodeRegister;
+			this.addNodeOptions(this.formatImportModule(tsNodeRegister));
+			this.env.EGG_TYPESCRIPT = "true";
+			process.env.EGG_TYPESCRIPT = "true";
+			this.env.TS_NODE_FILES = process.env.TS_NODE_FILES ?? "true";
+			const tsConfigPathsRegister = importResolve("tsconfig-paths/register", { paths: findPaths });
+			this.addNodeOptions(this.formatImportModule(tsConfigPathsRegister));
+		}
+		if (this.isESM) {
+			let esmLoader = importResolve("ts-node/esm", { paths: findPaths });
+			esmLoader = pathToFileURL(esmLoader).href;
+			this.addNodeOptions("--no-warnings");
+			this.addNodeOptions(`--loader ${esmLoader}`);
+		}
+		if (flags.declarations === void 0) {
+			if (typeof this.pkgEgg.declarations === "boolean") {
+				flags.declarations = this.pkgEgg.declarations;
+				debug("detect declarations from pkg.egg.declarations=%o", this.pkgEgg.declarations);
+			}
+		}
+		if (flags.declarations) {
+			const etsBin = importResolve("egg-ts-helper/dist/bin", { paths: findPaths });
+			debug("run ets first: %o", etsBin);
+			await runScript(`node "${etsBin}"`);
+		}
+		if (this.pkgEgg.revert) {
+			const reverts = Array.isArray(this.pkgEgg.revert) ? this.pkgEgg.revert : [this.pkgEgg.revert];
+			for (const revert of reverts) this.globalExecArgv.push(`--security-revert=${revert}`);
+		}
+		let hasInspectOption = false;
+		if (flags.inspect) {
+			this.addNodeOptions("--inspect");
+			hasInspectOption = true;
+		}
+		if (flags["inspect-brk"]) {
+			this.addNodeOptions("--inspect-brk");
+			hasInspectOption = true;
+		}
+		if (hasInspectOption) {
+			Reflect.set(flags, "timeout", 0);
+			debug("set timeout = 0 when inspect enable");
+		} else if (this.env.JB_DEBUG_FILE) {
+			Reflect.set(flags, "timeout", 0);
+			debug("set timeout = false when process.env.JB_DEBUG_FILE=%o", this.env.JB_DEBUG_FILE);
+		}
+		debug("baseDir: %o, isESM: %o", flags.base, this.isESM);
+		debug("set NODE_OPTIONS: %o", this.env.NODE_OPTIONS);
+		debug("after: args: %o, flags: %o", args, flags);
+		debug("enter real command: %o", this.id);
+	}
+	async catch(err) {
+		return super.catch(err);
+	}
+	async finally(_) {
+		return super.finally(_);
+	}
+	async formatRequires() {
+		const requires = this.flags.require ?? [];
+		const imports = this.flags.import ?? [];
+		let eggRequires = this.pkgEgg.require ?? [];
+		if (typeof eggRequires === "string") eggRequires = [eggRequires];
+		let eggImports = this.pkgEgg.import ?? [];
+		if (typeof eggImports === "string") eggImports = [eggImports];
+		return [
+			...requires,
+			...imports,
+			...eggRequires,
+			...eggImports
+		];
+	}
+	formatImportModule(modulePath) {
+		if (this.isESM) return `--import "${pathToFileURL(modulePath).href}"`;
+		if (os.platform() === "win32") return `--require "${path.win32.normalize(modulePath).replace(/\\/g, "\\\\")}"`;
+		return `--require "${modulePath}"`;
+	}
+	addNodeOptions(options) {
+		if (this.env.NODE_OPTIONS) {
+			if (!this.env.NODE_OPTIONS.includes(options)) this.env.NODE_OPTIONS = `${this.env.NODE_OPTIONS} ${options}`;
+		} else this.env.NODE_OPTIONS = options;
+	}
+	async forkNode(modulePath, forkArgs, options = {}) {
+		const env = {
+			...this.env,
+			...options.env
+		};
+		const forkExecArgv = [...this.globalExecArgv, ...options.execArgv || []];
+		const NODE_OPTIONS = env.NODE_OPTIONS ? `NODE_OPTIONS='${env.NODE_OPTIONS}' ` : "";
+		const forkExecArgvString = forkExecArgv.length ? " " + forkExecArgv.join(" ") + " " : " ";
+		const forkArgsString = forkArgs.map((a) => `'${a}'`).join(" ");
+		const fullCommand = `${NODE_OPTIONS}${process.execPath}${forkExecArgvString}${modulePath} ${forkArgsString}`;
+		if (options.dryRun) {
+			console.log("dry run: $ %s", fullCommand);
+			return;
+		}
+		options = {
+			stdio: "inherit",
+			env,
+			cwd: this.flags.base,
+			...options,
+			execArgv: forkExecArgv
+		};
+		const proc = fork(modulePath, forkArgs, options);
+		debug("Run fork pid: %o\n\n$ %s\n\n", proc.pid, fullCommand);
+		graceful(proc);
+		return new Promise((resolve, reject) => {
+			proc.once("exit", (code) => {
+				debug("fork pid: %o exit code %o", proc.pid, code);
+				children.delete(proc);
+				if (code !== 0) {
+					const err = new ForkError(modulePath + " " + forkArgs.join(" ") + " exit with code " + code, code);
+					reject(err);
+				} else resolve();
+			});
+		});
+	}
+};
+
+//#endregion
+export { BaseCommand, ForkError };

package/dist/commands/cov.d.ts

@@ -0,0 +1,27 @@
+import { ForkNodeOptions } from "../baseCommand.js";
+import { Test } from "./test.js";
+import * as _oclif_core_interfaces6 from "@oclif/core/interfaces";
+
+//#region src/commands/cov.d.ts
+declare class Cov<T extends typeof Cov> extends Test<T> {
+  static description: string;
+  static examples: string[];
+  static flags: {
+    prerequire: _oclif_core_interfaces6.BooleanFlag<boolean>;
+    exclude: _oclif_core_interfaces6.OptionFlag<string[] | undefined, _oclif_core_interfaces6.CustomOptions>;
+    c8: _oclif_core_interfaces6.OptionFlag<string, _oclif_core_interfaces6.CustomOptions>;
+    bail: _oclif_core_interfaces6.BooleanFlag<boolean>;
+    timeout: _oclif_core_interfaces6.OptionFlag<number, _oclif_core_interfaces6.CustomOptions>;
+    'no-timeout': _oclif_core_interfaces6.BooleanFlag<boolean>;
+    grep: _oclif_core_interfaces6.OptionFlag<string | undefined, _oclif_core_interfaces6.CustomOptions>;
+    changed: _oclif_core_interfaces6.BooleanFlag<boolean>;
+    mochawesome: _oclif_core_interfaces6.BooleanFlag<boolean>;
+    parallel: _oclif_core_interfaces6.BooleanFlag<boolean>;
+    jobs: _oclif_core_interfaces6.OptionFlag<number, _oclif_core_interfaces6.CustomOptions>;
+    'auto-agent': _oclif_core_interfaces6.BooleanFlag<boolean>;
+  };
+  protected get defaultExcludes(): string[];
+  protected forkNode(modulePath: string, forkArgs: string[], options?: ForkNodeOptions): Promise<void>;
+}
+//#endregion
+export { Cov };

package/dist/commands/cov.js

@@ -0,0 +1,86 @@
+import "../baseCommand.js";
+import Test from "./test.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { Flags } from "@oclif/core";
+import { importResolve } from "@eggjs/utils";
+
+//#region src/commands/cov.ts
+var Cov = class extends Test {
+	static description = "Run the test with coverage";
+	static examples = [
+		"<%= config.bin %> <%= command.id %>",
+		"<%= config.bin %> <%= command.id %> test/index.test.ts",
+		"<%= config.bin %> <%= command.id %> test/index.test.ts,test/user.test.ts,..."
+	];
+	static flags = {
+		...Test.flags,
+		prerequire: Flags.boolean({ description: "prerequire files for coverage instrument" }),
+		exclude: Flags.string({
+			description: "coverage ignore, one or more files patterns`",
+			multiple: true,
+			char: "x"
+		}),
+		c8: Flags.string({
+			description: "c8 instruments passthrough`",
+			default: "--temp-directory node_modules/.c8_output -r text-summary -r json-summary -r json -r lcov -r cobertura"
+		})
+	};
+	get defaultExcludes() {
+		return [
+			"example/",
+			"examples/",
+			"mocks**/",
+			"docs/",
+			"test/**",
+			"test{,-*}.js",
+			"**/*.test.js",
+			"**/__tests__/**",
+			"**/node_modules/**",
+			"typings",
+			"**/*.d.ts"
+		];
+	}
+	async forkNode(modulePath, forkArgs, options = {}) {
+		const { flags } = this;
+		if (flags.prerequire) this.env.EGG_BIN_PREREQUIRE = "true";
+		const c8Args = flags.c8.split(" ").filter((a) => a.trim());
+		if (flags.typescript) {
+			this.env.SPAWN_WRAP_SHIM_ROOT = path.join(flags.base, "node_modules");
+			c8Args.push("--extension");
+			c8Args.push(".ts");
+		}
+		const excludes = new Set([
+			...process.env.COV_EXCLUDES?.split(",") ?? [],
+			...this.defaultExcludes,
+			...Array.from(flags.exclude ?? [])
+		]);
+		for (const exclude of excludes) {
+			c8Args.push("-x");
+			c8Args.push(exclude);
+		}
+		const c8File = importResolve("c8/bin/c8.js");
+		const outputDir = path.join(flags.base, "node_modules/.c8_output");
+		await fs.rm(outputDir, {
+			force: true,
+			recursive: true
+		});
+		const coverageDir = path.join(flags.base, "coverage");
+		await fs.rm(coverageDir, {
+			force: true,
+			recursive: true
+		});
+		const execArgv = [...this.globalExecArgv, ...options.execArgv || []];
+		this.globalExecArgv = [];
+		await super.forkNode(c8File, [
+			...c8Args,
+			process.execPath,
+			...execArgv,
+			modulePath,
+			...forkArgs
+		]);
+	}
+};
+
+//#endregion
+export { Cov as default };

package/dist/commands/dev.d.ts

@@ -0,0 +1,26 @@
+import { BaseCommand } from "../baseCommand.js";
+import * as _oclif_core_interfaces0 from "@oclif/core/interfaces";
+
+//#region src/commands/dev.d.ts
+declare class Dev<T extends typeof Dev> extends BaseCommand<T> {
+  static description: string;
+  static examples: string[];
+  static flags: {
+    port: _oclif_core_interfaces0.OptionFlag<number | undefined, _oclif_core_interfaces0.CustomOptions>;
+    workers: _oclif_core_interfaces0.OptionFlag<number, _oclif_core_interfaces0.CustomOptions>;
+    framework: _oclif_core_interfaces0.OptionFlag<string | undefined, _oclif_core_interfaces0.CustomOptions>;
+    sticky: _oclif_core_interfaces0.BooleanFlag<boolean>;
+  };
+  run(): Promise<void>;
+  protected formatEggStartOptions(): Promise<{
+    baseDir: string;
+    workers: number;
+    port: number;
+    framework: string;
+    typescript: boolean;
+    tscompiler: string | undefined;
+    sticky: boolean;
+  }>;
+}
+//#endregion
+export { Dev };

package/dist/commands/dev.js

@@ -0,0 +1,86 @@
+import { getSourceFilename } from "../utils.js";
+import { BaseCommand } from "../baseCommand.js";
+import { debuglog } from "node:util";
+import { Flags } from "@oclif/core";
+import { getConfig, getFrameworkPath } from "@eggjs/utils";
+import { detect } from "detect-port";
+
+//#region src/commands/dev.ts
+const debug = debuglog("egg-bin/commands/dev");
+var Dev = class extends BaseCommand {
+	static description = "Start server at local dev mode";
+	static examples = ["<%= config.bin %> <%= command.id %>"];
+	static flags = {
+		port: Flags.integer({
+			description: "listening port, default to 7001",
+			char: "p"
+		}),
+		workers: Flags.integer({
+			char: "c",
+			aliases: ["cluster"],
+			description: "numbers of app workers",
+			default: 1
+		}),
+		framework: Flags.string({ description: "specify framework that can be absolute path or npm package, default is \"egg\"" }),
+		sticky: Flags.boolean({ description: "start a sticky cluster server" })
+	};
+	async run() {
+		debug("NODE_ENV: %o", this.env);
+		this.env.NODE_ENV = this.env.NODE_ENV ?? "development";
+		this.env.EGG_MASTER_CLOSE_TIMEOUT = "1000";
+		const ext = this.isESM ? "mjs" : "cjs";
+		const serverBin = getSourceFilename(`../scripts/start-cluster.${ext}`);
+		const eggStartOptions = await this.formatEggStartOptions();
+		const args = [JSON.stringify(eggStartOptions)];
+		const requires = await this.formatRequires();
+		const execArgv = [];
+		for (const r of requires) {
+			const module = this.formatImportModule(r);
+			const splitIndex = module.indexOf(" ");
+			if (splitIndex !== -1) execArgv.push(module.slice(0, splitIndex), module.slice(splitIndex + 2, -1));
+		}
+		await this.forkNode(serverBin, args, { execArgv });
+	}
+	async formatEggStartOptions() {
+		const { flags } = this;
+		flags.framework = getFrameworkPath({
+			framework: flags.framework,
+			baseDir: flags.base
+		});
+		if (!flags.port) {
+			let configuredPort;
+			try {
+				configuredPort = (await getConfig({
+					framework: flags.framework,
+					baseDir: flags.base,
+					env: "local"
+				}))?.cluster?.listen?.port;
+			} catch (err) {
+				/** skip when failing to read the configuration */
+				debug("getConfig error: %s, framework: %o, baseDir: %o, env: local", err, flags.framework, flags.base);
+			}
+			if (configuredPort) {
+				flags.port = configuredPort;
+				debug(`use port ${flags.port} from configuration file`);
+			} else {
+				const defaultPort = parseInt(process.env.EGG_BIN_DEFAULT_PORT ?? "7001");
+				debug("detect available port");
+				flags.port = await detect(defaultPort);
+				if (flags.port !== defaultPort) console.warn("[@eggjs/bin] server port %o is unavailable, now using port %o", defaultPort, flags.port);
+				debug(`use available port ${flags.port}`);
+			}
+		}
+		return {
+			baseDir: flags.base,
+			workers: flags.workers,
+			port: flags.port,
+			framework: flags.framework,
+			typescript: flags.typescript,
+			tscompiler: flags.tscompiler,
+			sticky: flags.sticky
+		};
+	}
+};
+
+//#endregion
+export { Dev as default };

package/dist/commands/test.d.ts

@@ -0,0 +1,28 @@
+import { BaseCommand } from "../baseCommand.js";
+import * as _oclif_core_interfaces23 from "@oclif/core/interfaces";
+
+//#region src/commands/test.d.ts
+declare class Test<T extends typeof Test> extends BaseCommand<T> {
+  static args: {
+    file: _oclif_core_interfaces23.Arg<string | undefined, Record<string, unknown>>;
+  };
+  static description: string;
+  static examples: string[];
+  static flags: {
+    bail: _oclif_core_interfaces23.BooleanFlag<boolean>;
+    timeout: _oclif_core_interfaces23.OptionFlag<number, _oclif_core_interfaces23.CustomOptions>;
+    'no-timeout': _oclif_core_interfaces23.BooleanFlag<boolean>;
+    grep: _oclif_core_interfaces23.OptionFlag<string | undefined, _oclif_core_interfaces23.CustomOptions>;
+    changed: _oclif_core_interfaces23.BooleanFlag<boolean>;
+    mochawesome: _oclif_core_interfaces23.BooleanFlag<boolean>;
+    parallel: _oclif_core_interfaces23.BooleanFlag<boolean>;
+    jobs: _oclif_core_interfaces23.OptionFlag<number, _oclif_core_interfaces23.CustomOptions>;
+    'auto-agent': _oclif_core_interfaces23.BooleanFlag<boolean>;
+  };
+  run(): Promise<void>;
+  protected runMocha(mochaFile: string, mochaArgs: string[]): Promise<void>;
+  protected formatMochaArgs(): Promise<string[] | undefined>;
+  protected getChangedTestFiles(dir: string, ext: string): Promise<string[]>;
+}
+//#endregion
+export { Test };