@eggjs/scripts 4.0.0 → 5.0.0-beta.27

package/README.md

@@ -1,16 +1,12 @@
 # @eggjs/scripts
 
 [![NPM version][npm-image]][npm-url]
-[![Node.js CI](https://github.com/eggjs/scripts/actions/workflows/nodejs.yml/badge.svg)](https://github.com/eggjs/scripts/actions/workflows/nodejs.yml)
-[![Test coverage][codecov-image]][codecov-url]
 [![npm download][download-image]][download-url]
 [![Node.js Version](https://img.shields.io/node/v/@eggjs/scripts.svg?style=flat)](https://nodejs.org/en/download/)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://makeapullrequest.com)
 
 [npm-image]: https://img.shields.io/npm/v/@eggjs/scripts.svg?style=flat-square
 [npm-url]: https://npmjs.org/package/@eggjs/scripts
-[codecov-image]: https://codecov.io/github/eggjs/scripts/coverage.svg?branch=master
-[codecov-url]: https://codecov.io/github/eggjs/scripts?branch=master
 [download-image]: https://img.shields.io/npm/dm/@eggjs/scripts.svg?style=flat-square
 [download-url]: https://npmjs.org/package/@eggjs/scripts
 
@@ -63,7 +59,7 @@ $ eggctl start [options] [baseDir]
 - **Options**
   - `port` - listening port, default to `process.env.PORT`, if unset, egg will use `7001` as default.
   - `title` - process title description, use for kill grep, default to `egg-server-${APP_NAME}`.
-  - `workers` - numbers of app workers, default to `process.env.EGG_WORKERS`, if unset, egg will use `os.cpus().length`  as default.
+  - `workers` - numbers of app workers, default to `process.env.EGG_WORKERS`, if unset, egg will use `os.cpus().length` as default.
   - `daemon` - whether run at background daemon mode, don't use it if in docker mode.
   - `framework` - specify framework that can be absolute path or npm package, default to auto detect.
   - `env` - server env, default to `process.env.EGG_SERVER_ENV`, recommended to keep empty then use framwork default env.
@@ -118,6 +114,6 @@ Please open an issue [here](https://github.com/eggjs/egg/issues?q=is%3Aissue+is%
 
 ## Contributors
 
-[![Contributors](https://contrib.rocks/image?repo=eggjs/scripts)](https://github.com/eggjs/scripts/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,28 @@
+import { PackageEgg } from "./types.js";
+import { Command, Interfaces } from "@oclif/core";
+
+//#region src/baseCommand.d.ts
+type Flags$1<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 {
+  static enableJsonFlag: boolean;
+  static baseFlags: {};
+  protected flags: Flags$1<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 initBaseInfo(baseDir: string): Promise<void>;
+  protected catch(err: Error & {
+    exitCode?: number;
+  }): Promise<any>;
+  protected finally(_: Error | undefined): Promise<any>;
+}
+//#endregion
+export { BaseCommand };

package/dist/baseCommand.js

@@ -0,0 +1,47 @@
+import { debuglog } from "node:util";
+import path from "node:path";
+import { Command, Interfaces } from "@oclif/core";
+import { readJSON } from "utility";
+
+//#region src/baseCommand.ts
+const debug = debuglog("egg/scripts/baseCommand");
+var BaseCommand = class extends Command {
+	static enableJsonFlag = false;
+	static baseFlags = {};
+	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;
+	}
+	async initBaseInfo(baseDir) {
+		const pkg = await readJSON(path.join(baseDir, "package.json"));
+		this.pkg = pkg;
+		this.pkgEgg = pkg.egg ?? {};
+		this.isESM = pkg.type === "module";
+		debug("[initBaseInfo] baseDir: %o, pkgEgg: %o, isESM: %o", baseDir, this.pkgEgg, this.isESM);
+	}
+	async catch(err) {
+		return super.catch(err);
+	}
+	async finally(_) {
+		return super.finally(_);
+	}
+};
+
+//#endregion
+export { BaseCommand };

package/dist/commands/start.d.ts

@@ -0,0 +1,39 @@
+import { BaseCommand } from "../baseCommand.js";
+import * as _oclif_core_interfaces4 from "@oclif/core/interfaces";
+
+//#region src/commands/start.d.ts
+interface FrameworkOptions {
+  baseDir: string;
+  framework?: string;
+}
+declare class Start<T extends typeof Start> extends BaseCommand<T> {
+  #private;
+  static description: string;
+  static examples: string[];
+  static args: {
+    baseDir: _oclif_core_interfaces4.Arg<string | undefined, Record<string, unknown>>;
+  };
+  static flags: {
+    title: _oclif_core_interfaces4.OptionFlag<string | undefined, _oclif_core_interfaces4.CustomOptions>;
+    framework: _oclif_core_interfaces4.OptionFlag<string | undefined, _oclif_core_interfaces4.CustomOptions>;
+    port: _oclif_core_interfaces4.OptionFlag<number | undefined, _oclif_core_interfaces4.CustomOptions>;
+    workers: _oclif_core_interfaces4.OptionFlag<number | undefined, _oclif_core_interfaces4.CustomOptions>;
+    env: _oclif_core_interfaces4.OptionFlag<string, _oclif_core_interfaces4.CustomOptions>;
+    daemon: _oclif_core_interfaces4.BooleanFlag<boolean>;
+    stdout: _oclif_core_interfaces4.OptionFlag<string | undefined, _oclif_core_interfaces4.CustomOptions>;
+    stderr: _oclif_core_interfaces4.OptionFlag<string | undefined, _oclif_core_interfaces4.CustomOptions>;
+    timeout: _oclif_core_interfaces4.OptionFlag<number, _oclif_core_interfaces4.CustomOptions>;
+    'ignore-stderr': _oclif_core_interfaces4.BooleanFlag<boolean>;
+    node: _oclif_core_interfaces4.OptionFlag<string, _oclif_core_interfaces4.CustomOptions>;
+    require: _oclif_core_interfaces4.OptionFlag<string[] | undefined, _oclif_core_interfaces4.CustomOptions>;
+    sourcemap: _oclif_core_interfaces4.BooleanFlag<boolean>;
+  };
+  isReady: boolean;
+  protected getFrameworkPath(options: FrameworkOptions): Promise<string>;
+  protected getFrameworkName(frameworkPath: string): Promise<string>;
+  protected getServerBin(): Promise<string>;
+  run(): Promise<void>;
+  protected checkStatus(): Promise<void>;
+}
+//#endregion
+export { FrameworkOptions, Start as default };

package/dist/commands/start.js

@@ -0,0 +1,277 @@
+import { BaseCommand } from "../baseCommand.js";
+import { debuglog, promisify } from "node:util";
+import path from "node:path";
+import { Args, Flags } from "@oclif/core";
+import { exists, getDateStringParts, readJSON } from "utility";
+import { scheduler } from "node:timers/promises";
+import { execFile, spawn } from "node:child_process";
+import { mkdir, open, rename, stat } from "node:fs/promises";
+import { homedir } from "node-homedir";
+import { getFrameworkPath, importResolve } from "@eggjs/utils";
+
+//#region src/commands/start.ts
+const debug = debuglog("egg/scripts/commands/start");
+const execFile$1 = promisify(execFile);
+var Start = class extends BaseCommand {
+	static description = "Start server at prod mode";
+	static examples = ["<%= config.bin %> <%= command.id %>"];
+	static args = { baseDir: Args.string({
+		description: "directory of application",
+		required: false
+	}) };
+	static flags = {
+		title: Flags.string({ description: "process title description, use for kill grep, default to `egg-server-${APP_NAME}`" }),
+		framework: Flags.string({ description: "specify framework that can be absolute path or npm package" }),
+		port: Flags.integer({
+			description: "listening port, default to `process.env.PORT`",
+			char: "p"
+		}),
+		workers: Flags.integer({
+			char: "c",
+			aliases: ["cluster"],
+			description: "numbers of app workers, default to `process.env.EGG_WORKERS` or `os.cpus().length`"
+		}),
+		env: Flags.string({
+			description: "server env, default to `process.env.EGG_SERVER_ENV`",
+			default: process.env.EGG_SERVER_ENV
+		}),
+		daemon: Flags.boolean({ description: "whether run at background daemon mode" }),
+		stdout: Flags.string({ description: "customize stdout file" }),
+		stderr: Flags.string({ description: "customize stderr file" }),
+		timeout: Flags.integer({
+			description: "the maximum timeout(ms) when app starts",
+			default: 300 * 1e3
+		}),
+		"ignore-stderr": Flags.boolean({ description: "whether ignore stderr when app starts" }),
+		node: Flags.string({
+			description: "customize node command path",
+			default: "node"
+		}),
+		require: Flags.string({
+			summary: "require the given module",
+			char: "r",
+			multiple: true
+		}),
+		sourcemap: Flags.boolean({
+			summary: "whether enable sourcemap support, will load `source-map-support` etc",
+			aliases: ["ts", "typescript"]
+		})
+	};
+	isReady = false;
+	#child;
+	async getFrameworkPath(options) {
+		return getFrameworkPath(options);
+	}
+	async getFrameworkName(frameworkPath) {
+		const pkgPath = path.join(frameworkPath, "package.json");
+		let name = "egg";
+		try {
+			const pkg = await readJSON(pkgPath);
+			if (pkg.name) name = pkg.name;
+		} catch {}
+		return name;
+	}
+	async getServerBin() {
+		const serverBinName = this.isESM ? "start-cluster.mjs" : "start-cluster.cjs";
+		return path.join(import.meta.dirname, "../../scripts", serverBinName);
+	}
+	async run() {
+		const { args, flags } = this;
+		const HOME = homedir();
+		const logDir = path.join(HOME, "logs");
+		const cwd = process.cwd();
+		let baseDir = args.baseDir || cwd;
+		if (!path.isAbsolute(baseDir)) baseDir = path.join(cwd, baseDir);
+		await this.initBaseInfo(baseDir);
+		flags.framework = await this.getFrameworkPath({
+			framework: flags.framework,
+			baseDir
+		});
+		const frameworkName = await this.getFrameworkName(flags.framework);
+		flags.title = flags.title || `egg-server-${this.pkg.name}`;
+		flags.stdout = flags.stdout || path.join(logDir, "master-stdout.log");
+		flags.stderr = flags.stderr || path.join(logDir, "master-stderr.log");
+		if (flags.workers === void 0 && process.env.EGG_WORKERS) flags.workers = Number(process.env.EGG_WORKERS);
+		this.env.HOME = HOME;
+		this.env.NODE_ENV = "production";
+		this.env.PATH = this.env.Path = [
+			path.join(baseDir, "node_modules/.bin"),
+			path.join(baseDir, ".node/bin"),
+			this.env.PATH || this.env.Path
+		].filter((x) => !!x).join(path.delimiter);
+		this.env.ENABLE_NODE_LOG = "YES";
+		this.env.NODE_LOG_DIR = this.env.NODE_LOG_DIR || path.join(logDir, "alinode");
+		await mkdir(this.env.NODE_LOG_DIR, { recursive: true });
+		if (flags.env) this.env.EGG_SERVER_ENV = flags.env;
+		const execArgv = ["--no-deprecation", "--trace-warnings"];
+		if (this.pkgEgg.revert) {
+			const reverts = Array.isArray(this.pkgEgg.revert) ? this.pkgEgg.revert : [this.pkgEgg.revert];
+			for (const revert of reverts) execArgv.push(`--security-revert=${revert}`);
+		}
+		const scriptsConfig = this.pkg.eggScriptsConfig;
+		if (scriptsConfig?.require) {
+			scriptsConfig.require = Array.isArray(scriptsConfig.require) ? scriptsConfig.require : [scriptsConfig.require];
+			flags.require = [...scriptsConfig.require, ...flags.require ?? []];
+		}
+		if (scriptsConfig) for (const key in scriptsConfig) {
+			const v = scriptsConfig[key];
+			if (key.startsWith("node-options--")) {
+				const newKey = key.replace("node-options--", "");
+				if (v === true) execArgv.push(`--${newKey}`);
+				else execArgv.push(`--${newKey}=${v}`);
+				continue;
+			}
+			if (Reflect.get(flags, key) === void 0) Reflect.set(flags, key, v);
+		}
+		if (this.pkgEgg.typescript && flags.sourcemap === void 0) flags.sourcemap = true;
+		if (flags.sourcemap) {
+			const sourceMapSupportPkgPath = importResolve("source-map-support/package.json", { paths: [import.meta.dirname] });
+			const sourceMapSupport = path.join(path.dirname(sourceMapSupportPkgPath), "register.js");
+			if (this.isESM) execArgv.push("--import", sourceMapSupport);
+			else execArgv.push("--require", sourceMapSupport);
+		}
+		if (flags.port === void 0 && process.env.PORT) flags.port = parseInt(process.env.PORT);
+		debug("flags: %o, framework: %o, baseDir: %o, execArgv: %o", flags, frameworkName, baseDir, execArgv);
+		const command = flags.node;
+		const options = {
+			env: this.env,
+			stdio: "inherit",
+			detached: false,
+			cwd: baseDir
+		};
+		this.log("Starting %s application at %s", frameworkName, baseDir);
+		const ignoreKeys = [
+			"env",
+			"daemon",
+			"stdout",
+			"stderr",
+			"timeout",
+			"ignore-stderr",
+			"node"
+		];
+		const clusterOptions = stringify({
+			...flags,
+			baseDir
+		}, ignoreKeys);
+		const serverBin = await this.getServerBin();
+		const eggArgs = [
+			...execArgv,
+			serverBin,
+			clusterOptions,
+			`--title=${flags.title}`
+		];
+		const spawnScript = `${command} ${eggArgs.map((a) => `'${a}'`).join(" ")}`;
+		this.log("Spawn %o", spawnScript);
+		if (flags.daemon) {
+			this.log(`Save log file to ${logDir}`);
+			const [stdout, stderr] = await Promise.all([getRotateLog(flags.stdout), getRotateLog(flags.stderr)]);
+			options.stdio = [
+				"ignore",
+				stdout,
+				stderr,
+				"ipc"
+			];
+			options.detached = true;
+			const child = this.#child = spawn(command, eggArgs, options);
+			this.isReady = false;
+			child.on("message", (msg) => {
+				if (msg && msg.action === "egg-ready") {
+					this.isReady = true;
+					this.log("%s started on %s", frameworkName, msg.data.address);
+					child.unref();
+					child.disconnect();
+				}
+			});
+			await this.checkStatus();
+		} else {
+			options.stdio = [
+				"inherit",
+				"inherit",
+				"inherit",
+				"ipc"
+			];
+			const child = this.#child = spawn(command, eggArgs, options);
+			child.once("exit", (code) => {
+				if (!code) return;
+				this.exit(code);
+			});
+			[
+				"SIGINT",
+				"SIGQUIT",
+				"SIGTERM"
+			].forEach((event) => {
+				process.once(event, () => {
+					debug("Kill child %s with %s", child.pid, event);
+					child.kill(event);
+				});
+			});
+		}
+	}
+	async checkStatus() {
+		let count = 0;
+		let hasError = false;
+		let isSuccess = true;
+		const timeout = this.flags.timeout / 1e3;
+		const stderrFile = this.flags.stderr;
+		while (!this.isReady) {
+			try {
+				const stats = await stat(stderrFile);
+				if (stats && stats.size > 0) {
+					hasError = true;
+					break;
+				}
+			} catch {}
+			if (count >= timeout) {
+				this.logToStderr("Start failed, %ds timeout", timeout);
+				isSuccess = false;
+				break;
+			}
+			await scheduler.wait(1e3);
+			this.log("Wait Start: %d...", ++count);
+		}
+		if (hasError) {
+			try {
+				const args = [
+					"-n",
+					"100",
+					stderrFile
+				];
+				this.logToStderr("tail %s", args.join(" "));
+				const { stdout: headStdout } = await execFile$1("head", args);
+				const { stdout: tailStdout } = await execFile$1("tail", args);
+				this.logToStderr("Got error when startup: ");
+				this.logToStderr(headStdout);
+				this.logToStderr("...");
+				this.logToStderr(tailStdout);
+			} catch (err) {
+				this.logToStderr("ignore tail error: %s", err);
+			}
+			isSuccess = this.flags["ignore-stderr"];
+			this.logToStderr("Start got error, see %o", stderrFile);
+			this.logToStderr("Or use `--ignore-stderr` to ignore stderr at startup.");
+		}
+		if (!isSuccess) {
+			this.#child.kill("SIGTERM");
+			await scheduler.wait(1e3);
+			this.exit(1);
+		}
+	}
+};
+function stringify(obj, ignore) {
+	const result = {};
+	Object.keys(obj).forEach((key) => {
+		if (!ignore.includes(key)) result[key] = obj[key];
+	});
+	return JSON.stringify(result);
+}
+async function getRotateLog(logFile) {
+	await mkdir(path.dirname(logFile), { recursive: true });
+	if (await exists(logFile)) {
+		const [YYYY, MM, DD, HH, mm, ss] = getDateStringParts();
+		await rename(logFile, logFile + `.${YYYY}${MM}${DD}.${HH}${mm}${ss}`);
+	}
+	return (await open(logFile, "a")).fd;
+}
+
+//#endregion
+export { Start as default };

package/dist/commands/stop.d.ts

@@ -0,0 +1,21 @@
+import { BaseCommand } from "../baseCommand.js";
+import { NodeProcess } from "../helper.js";
+import * as _oclif_core_interfaces0 from "@oclif/core/interfaces";
+
+//#region src/commands/stop.d.ts
+declare class Stop<T extends typeof Stop> extends BaseCommand<T> {
+  static description: string;
+  static examples: string[];
+  static args: {
+    baseDir: _oclif_core_interfaces0.Arg<string | undefined, Record<string, unknown>>;
+  };
+  static flags: {
+    title: _oclif_core_interfaces0.OptionFlag<string | undefined, _oclif_core_interfaces0.CustomOptions>;
+    timeout: _oclif_core_interfaces0.OptionFlag<number, _oclif_core_interfaces0.CustomOptions>;
+  };
+  run(): Promise<void>;
+  protected findNodeProcesses(filter: (item: NodeProcess) => boolean): Promise<NodeProcess[]>;
+  protected killProcesses(pids: number[], signal?: NodeJS.Signals): void;
+}
+//#endregion
+export { Stop as default };

package/dist/commands/stop.js

@@ -0,0 +1,68 @@
+import { BaseCommand } from "../baseCommand.js";
+import { findNodeProcess, isWindows, kill } from "../helper.js";
+import { debuglog, format } from "node:util";
+import { Args, Flags } from "@oclif/core";
+import { scheduler } from "node:timers/promises";
+
+//#region src/commands/stop.ts
+const debug = debuglog("egg/scripts/commands/stop");
+const osRelated = {
+	titleTemplate: isWindows ? "\\\"title\\\":\\\"%s\\\"" : "\"title\":\"%s\"",
+	appWorkerPath: /@eggjs[/\\]cluster[/\\]dist[/\\](commonjs|esm)[/\\]app_worker\.js/i,
+	agentWorkerPath: /@eggjs[/\\]cluster[/\\]dist[/\\](commonjs|esm)[/\\]agent_worker\.js/i
+};
+var Stop = class extends BaseCommand {
+	static description = "Stop server";
+	static examples = ["<%= config.bin %> <%= command.id %>"];
+	static args = { baseDir: Args.string({
+		description: "directory of application",
+		required: false
+	}) };
+	static flags = {
+		title: Flags.string({ description: "process title description, use for kill grep" }),
+		timeout: Flags.integer({
+			description: "the maximum timeout(ms) when app stop",
+			default: 5e3
+		})
+	};
+	async run() {
+		const { flags } = this;
+		this.log(`stopping egg application${flags.title ? ` with --title=${flags.title}` : ""}`);
+		let processList = await this.findNodeProcesses((item) => {
+			const cmd = item.cmd;
+			const matched = flags.title ? cmd.includes("start-cluster") && cmd.includes(format(osRelated.titleTemplate, flags.title)) : cmd.includes("start-cluster");
+			if (matched) debug("find master process: %o", item);
+			return matched;
+		});
+		let pids = processList.map((x) => x.pid);
+		if (pids.length) {
+			this.log("got master pid %j, list:", pids);
+			this.log("");
+			for (const item of processList) this.log("- %s: %o", item.pid, item.cmd);
+			this.log("");
+			this.killProcesses(pids);
+			await scheduler.wait(flags.timeout);
+		} else this.logToStderr("can't detect any running egg process");
+		processList = await this.findNodeProcesses((item) => {
+			const cmd = item.cmd;
+			const matched = flags.title ? (osRelated.appWorkerPath.test(cmd) || osRelated.agentWorkerPath.test(cmd)) && cmd.includes(format(osRelated.titleTemplate, flags.title)) : osRelated.appWorkerPath.test(cmd) || osRelated.agentWorkerPath.test(cmd);
+			if (matched) debug("find app/agent worker process: %o", item);
+			return matched;
+		});
+		pids = processList.map((x) => x.pid);
+		if (pids.length) {
+			this.log("got worker/agent pids %j that is not killed by master", pids);
+			this.killProcesses(pids);
+		}
+		this.log("stopped");
+	}
+	async findNodeProcesses(filter) {
+		return findNodeProcess(filter);
+	}
+	killProcesses(pids, signal = "SIGTERM") {
+		kill(pids, signal);
+	}
+};
+
+//#endregion
+export { Stop as default };

package/dist/helper.d.ts

@@ -0,0 +1,11 @@
+//#region src/helper.d.ts
+declare const isWindows: boolean;
+interface NodeProcess {
+  pid: number;
+  cmd: string;
+}
+type FilterFunction = (item: NodeProcess) => boolean;
+declare function findNodeProcess(filterFn?: FilterFunction): Promise<NodeProcess[]>;
+declare function kill(pids: number[], signal?: string | number): void;
+//#endregion
+export { FilterFunction, NodeProcess, findNodeProcess, isWindows, kill };

package/dist/helper.js

@@ -0,0 +1,35 @@
+import { runScript } from "runscript";
+
+//#region src/helper.ts
+const isWindows = process.platform === "win32";
+const REGEX = isWindows ? /^(.*)\s+(\d+)\s*$/ : /^\s*(\d+)\s+(.*)/;
+async function findNodeProcess(filterFn) {
+	return (await runScript(isWindows ? "wmic Path win32_process Where \"Name = 'node.exe'\" Get CommandLine,ProcessId" : "ps -wweo \"pid,args\"", { stdio: "pipe" })).stdout.toString().split("\n").reduce((arr, line) => {
+		if (!!line && !line.includes("/bin/sh") && line.includes("node")) {
+			const m = line.match(REGEX);
+			if (m) {
+				const item = isWindows ? {
+					pid: parseInt(m[2]),
+					cmd: m[1]
+				} : {
+					pid: parseInt(m[1]),
+					cmd: m[2]
+				};
+				if (filterFn?.(item)) arr.push(item);
+			}
+		}
+		return arr;
+	}, []);
+}
+function kill(pids, signal) {
+	pids.forEach((pid) => {
+		try {
+			process.kill(pid, signal);
+		} catch (err) {
+			if (err.code !== "ESRCH") throw err;
+		}
+	});
+}
+
+//#endregion
+export { findNodeProcess, isWindows, kill };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { BaseCommand } from "./baseCommand.js";
+import Start from "./commands/start.js";
+export { BaseCommand, Start, Start as StartCommand };

package/dist/index.js

@@ -0,0 +1,4 @@
+import { BaseCommand } from "./baseCommand.js";
+import Start from "./commands/start.js";
+
+export { BaseCommand, Start, Start as StartCommand };

package/{src/types.ts → dist/types.d.ts}

@@ -1,4 +1,5 @@
-export interface PackageEgg {
+//#region src/types.d.ts
+interface PackageEgg {
   framework?: boolean;
   typescript?: boolean;
   tscompiler?: string;
@@ -7,3 +8,5 @@ export interface PackageEgg {
   require?: string | string[];
   import?: string | string[];
 }
+//#endregion
+export { PackageEgg };

package/dist/types.js

@@ -0,0 +1 @@
+export {  };