@eggjs/bin 8.0.2-beta.1 → 8.0.2-beta.10

package/README.md

@@ -36,6 +36,7 @@ Add `egg-bin` to `package.json` scripts:
     "test-local": "egg-bin test",
     "test": "npm run lint -- --fix && npm run test-local",
     "cov": "egg-bin cov",
+    "bundle": "egg-bin bundle",
     "lint": "eslint .",
     "ci": "npm run lint && npm run cov"
   }
@@ -183,6 +184,57 @@ You can set `COV_EXCLUDES` env to add glob patterns to exclude from coverage (co
 COV_EXCLUDES="app/plugins/c*,app/autocreate/**" egg-bin cov
 ```
 
+### bundle
+
+Bundle an Egg application into a deployable artifact with `@eggjs/egg-bundler`.
+
+```bash
+egg-bin bundle
+egg-bin bundle --output ./dist-bundle
+egg-bin bundle --mode development
+egg-bin bundle --framework egg --output ./out
+egg-bin bundle --pack-alias some-package=./node_modules/some-package/index.js
+```
+
+The command writes the bundle to `./dist-bundle` by default. The generated
+artifact can be started with Node from the output directory:
+
+```bash
+cd dist-bundle
+node worker.js
+```
+
+#### bundle options
+
+- `--output` / `-o` output directory, default to `./dist-bundle`
+- `--manifest` path to `manifest.json`, default to `<baseDir>/.egg/manifest.json`
+- `--framework` / `-f` framework package specifier, defaulting to
+  `package.json#egg.framework` or `egg`. Absolute framework paths are not
+  supported by the bundled runtime.
+- `--mode` build mode, `production` or `development`, default to `production`
+- `--force-external` package name to always keep external, supports multiple
+- `--inline-external` package name to force inline, supports multiple
+- `--pack-alias` `@utoo/pack` resolve alias in `<specifier>=<target>` form,
+  supports multiple. Dot-relative targets such as `./target.js` and
+  `../target.js` are resolved from the application base directory
+
+Bundle aliases can also be committed in the application `module.yml`:
+
+```yaml
+bundle:
+  pack:
+    resolve:
+      alias:
+        some-package: ./node_modules/some-package/index.js
+```
+
+`module.yml` aliases use the same target resolution rules as `--pack-alias`.
+If the same alias is configured in both places, the explicit CLI
+`--pack-alias` value wins.
+
+See [`@eggjs/egg-bundler`](../egg-bundler/README.md) for the programmatic API
+and output structure.
+
 ## Breaking Changes (v8)
 
 ### Migrated from Mocha to Vitest

package/dist/baseCommand.d.ts

@@ -32,7 +32,6 @@ declare abstract class BaseCommand<T extends typeof Command> extends Command {
   protected args: Args$1<T>;
   protected env: {
     [key: string]: string | undefined;
-    TZ?: string | undefined;
   };
   protected pkg: Record<string, any>;
   protected isESM: boolean;
@@ -46,6 +45,7 @@ declare abstract class BaseCommand<T extends typeof Command> extends Command {
   protected formatRequires(): Promise<string[]>;
   protected formatImportModule(modulePath: string): string;
   protected addNodeOptions(options: string): void;
+  protected buildRequiresExecArgv(): Promise<string[]>;
   protected forkNode(modulePath: string, forkArgs: string[], options?: ForkNodeOptions): Promise<void>;
 }
 //#endregion

package/dist/baseCommand.js

@@ -1,10 +1,10 @@
 import { getSourceDirname, hasTsConfig, readPackageJSON } from "./utils.js";
+import { createRequire } from "node:module";
 import { fork } from "node:child_process";
 import os from "node:os";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { debuglog } from "node:util";
-import { importResolve } from "@eggjs/utils";
 import { Command, Flags, Interfaces } from "@oclif/core";
 
 //#region src/baseCommand.ts
@@ -162,20 +162,26 @@ var BaseCommand = class extends Command {
 		let rootDir = path.dirname(getSourceDirname());
 		if (path.basename(rootDir) === "dist") rootDir = path.dirname(rootDir);
 		const findPaths = [flags.base, rootDir];
+		const cjsResolve = (specifier) => {
+			for (const p of findPaths) try {
+				return createRequire(path.join(p, "package.json")).resolve(specifier);
+			} catch {}
+			throw new Error(`Cannot resolve '${specifier}' from ${findPaths.join(", ")}`);
+		};
 		this.isESM = pkg.type === "module";
 		if (typescript) {
 			flags.tscompiler = flags.tscompiler ?? "ts-node/register";
-			const tsNodeRegister = importResolve(flags.tscompiler, { paths: findPaths });
+			const tsNodeRegister = cjsResolve(flags.tscompiler);
 			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 });
+			const tsConfigPathsRegister = cjsResolve("tsconfig-paths/register");
 			this.addNodeOptions(this.formatImportModule(tsConfigPathsRegister));
 		}
 		if (this.isESM) {
-			let esmLoader = importResolve("ts-node/esm", { paths: findPaths });
+			let esmLoader = cjsResolve("ts-node/esm");
 			esmLoader = pathToFileURL(esmLoader).href;
 			this.addNodeOptions("--no-warnings");
 			this.addNodeOptions(`--loader ${esmLoader}`);
@@ -235,6 +241,16 @@ var BaseCommand = class extends Command {
 			if (!this.env.NODE_OPTIONS.includes(options)) this.env.NODE_OPTIONS = `${this.env.NODE_OPTIONS} ${options}`;
 		} else this.env.NODE_OPTIONS = options;
 	}
+	async buildRequiresExecArgv() {
+		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));
+		}
+		return execArgv;
+	}
 	async forkNode(modulePath, forkArgs, options = {}) {
 		const env = {
 			...this.env,

package/dist/commands/bundle.d.ts

@@ -0,0 +1,20 @@
+import { BaseCommand } from "../baseCommand.js";
+import * as _oclif_core_interfaces18 from "@oclif/core/interfaces";
+
+//#region src/commands/bundle.d.ts
+declare class Bundle extends BaseCommand<typeof Bundle> {
+  static description: string;
+  static examples: string[];
+  static flags: {
+    output: _oclif_core_interfaces18.OptionFlag<string, _oclif_core_interfaces18.CustomOptions>;
+    manifest: _oclif_core_interfaces18.OptionFlag<string | undefined, _oclif_core_interfaces18.CustomOptions>;
+    framework: _oclif_core_interfaces18.OptionFlag<string | undefined, _oclif_core_interfaces18.CustomOptions>;
+    mode: _oclif_core_interfaces18.OptionFlag<string, _oclif_core_interfaces18.CustomOptions>;
+    'force-external': _oclif_core_interfaces18.OptionFlag<string[], _oclif_core_interfaces18.CustomOptions>;
+    'inline-external': _oclif_core_interfaces18.OptionFlag<string[], _oclif_core_interfaces18.CustomOptions>;
+    'pack-alias': _oclif_core_interfaces18.OptionFlag<string[], _oclif_core_interfaces18.CustomOptions>;
+  };
+  run(): Promise<void>;
+}
+//#endregion
+export { Bundle as default };

package/dist/commands/bundle.js

@@ -0,0 +1,99 @@
+import { BaseCommand } from "../baseCommand.js";
+import path from "node:path";
+import { debuglog } from "node:util";
+import { Flags } from "@oclif/core";
+import fs from "node:fs/promises";
+
+//#region src/commands/bundle.ts
+const debug = debuglog("egg/bin/commands/bundle");
+const bundleModes = ["production", "development"];
+function getBundleMode(mode) {
+	if (mode === "production" || mode === "development") return mode;
+	throw new Error(`Unsupported bundle mode: ${mode}`);
+}
+function parsePackAliases(values, baseDir) {
+	if (values.length === 0) return void 0;
+	const alias = {};
+	for (const value of values) {
+		const separator = value.indexOf("=");
+		if (separator <= 0 || separator === value.length - 1) throw new Error(`Invalid --pack-alias value: ${value}. Expected <specifier>=<target>.`);
+		const specifier = value.slice(0, separator);
+		const target = value.slice(separator + 1);
+		alias[specifier] = target.startsWith(".") ? path.resolve(baseDir, target) : target;
+	}
+	return alias;
+}
+async function getBundleFrameworkSpecifier(baseDir, framework) {
+	if (framework) return framework;
+	const pkgPath = path.join(baseDir, "package.json");
+	const pkg = JSON.parse(await fs.readFile(pkgPath, "utf8"));
+	return typeof pkg.egg?.framework === "string" && pkg.egg.framework ? pkg.egg.framework : "egg";
+}
+var Bundle = class extends BaseCommand {
+	static description = "Bundle an egg app into a deployable artifact using @eggjs/egg-bundler";
+	static examples = [
+		"<%= config.bin %> <%= command.id %>",
+		"<%= config.bin %> <%= command.id %> --output ./dist-bundle",
+		"<%= config.bin %> <%= command.id %> --mode development",
+		"<%= config.bin %> <%= command.id %> --framework egg --output ./out",
+		"<%= config.bin %> <%= command.id %> --pack-alias some-package=./node_modules/some-package/index.js"
+	];
+	static flags = {
+		output: Flags.string({
+			char: "o",
+			description: "output directory for the bundled artifact",
+			default: "./dist-bundle"
+		}),
+		manifest: Flags.string({ description: "path to manifest.json (defaults to <baseDir>/.egg/manifest.json)" }),
+		framework: Flags.string({
+			char: "f",
+			description: "framework package specifier"
+		}),
+		mode: Flags.string({
+			description: "build mode",
+			options: [...bundleModes],
+			default: "production"
+		}),
+		"force-external": Flags.string({
+			description: "package name to always mark as external (repeatable)",
+			multiple: true,
+			default: []
+		}),
+		"inline-external": Flags.string({
+			description: "package name to force-inline even if auto-detected as external (repeatable)",
+			multiple: true,
+			default: []
+		}),
+		"pack-alias": Flags.string({
+			description: "@utoo/pack resolve alias in <specifier>=<target> form, dot-relative targets resolve from --base",
+			multiple: true,
+			default: []
+		})
+	};
+	async run() {
+		const { flags } = this;
+		const baseDir = flags.base;
+		const outputDir = path.isAbsolute(flags.output) ? flags.output : path.join(baseDir, flags.output);
+		const manifestPath = flags.manifest ? path.isAbsolute(flags.manifest) ? flags.manifest : path.join(baseDir, flags.manifest) : void 0;
+		debug("bundle: baseDir=%s, outputDir=%s, framework=%s, mode=%s", baseDir, outputDir, flags.framework, flags.mode);
+		const { bundle } = await import("@eggjs/egg-bundler");
+		const packAlias = parsePackAliases(flags["pack-alias"], baseDir);
+		const result = await bundle({
+			baseDir,
+			outputDir,
+			manifestPath,
+			framework: await getBundleFrameworkSpecifier(baseDir, flags.framework),
+			mode: getBundleMode(flags.mode),
+			externals: {
+				force: flags["force-external"],
+				inline: flags["inline-external"]
+			},
+			...packAlias ? { pack: { resolve: { alias: packAlias } } } : {}
+		});
+		this.log(`bundled to ${result.outputDir} (${result.files.length} files)`);
+		this.log(`manifest: ${result.manifestPath}`);
+	}
+};
+
+//#endregion
+export { Bundle as default };

package/dist/commands/cov.d.ts

@@ -14,6 +14,7 @@ declare class Cov<T extends typeof Cov> extends Test<T> {
     grep: _oclif_core_interfaces0.OptionFlag<string | undefined, _oclif_core_interfaces0.CustomOptions>;
     changed: _oclif_core_interfaces0.BooleanFlag<boolean>;
     watch: _oclif_core_interfaces0.BooleanFlag<boolean>;
+    pool: _oclif_core_interfaces0.OptionFlag<string, _oclif_core_interfaces0.CustomOptions>;
   };
   protected get defaultCoverageExcludes(): string[];
   /**

package/dist/commands/dev.d.ts

@@ -1,15 +1,15 @@
 import { BaseCommand } from "../baseCommand.js";
-import * as _oclif_core_interfaces9 from "@oclif/core/interfaces";
+import * as _oclif_core_interfaces32 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_interfaces9.OptionFlag<number | undefined, _oclif_core_interfaces9.CustomOptions>;
-    workers: _oclif_core_interfaces9.OptionFlag<number, _oclif_core_interfaces9.CustomOptions>;
-    framework: _oclif_core_interfaces9.OptionFlag<string | undefined, _oclif_core_interfaces9.CustomOptions>;
-    sticky: _oclif_core_interfaces9.BooleanFlag<boolean>;
+    port: _oclif_core_interfaces32.OptionFlag<number | undefined, _oclif_core_interfaces32.CustomOptions>;
+    workers: _oclif_core_interfaces32.OptionFlag<number, _oclif_core_interfaces32.CustomOptions>;
+    framework: _oclif_core_interfaces32.OptionFlag<string | undefined, _oclif_core_interfaces32.CustomOptions>;
+    sticky: _oclif_core_interfaces32.BooleanFlag<boolean>;
   };
   run(): Promise<void>;
   protected formatEggStartOptions(): Promise<{

package/dist/commands/dev.js

@@ -1,8 +1,8 @@
 import { getSourceFilename } from "../utils.js";
 import { BaseCommand } from "../baseCommand.js";
 import { debuglog } from "node:util";
-import { getFrameworkPath } from "@eggjs/utils";
 import { Flags } from "@oclif/core";
+import { getFrameworkPath } from "@eggjs/utils";
 import { detect } from "detect-port";
 
 //#region src/commands/dev.ts
@@ -31,13 +31,7 @@ var Dev = class extends BaseCommand {
 		const serverBin = getSourceFilename(`../scripts/start-cluster.${this.isESM ? "mjs" : "cjs"}`);
 		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));
-		}
+		const execArgv = await this.buildRequiresExecArgv();
 		await this.forkNode(serverBin, args, { execArgv });
 	}
 	async formatEggStartOptions() {

package/dist/commands/manifest.d.ts

@@ -0,0 +1,22 @@
+import { BaseCommand } from "../baseCommand.js";
+import * as _oclif_core_interfaces11 from "@oclif/core/interfaces";
+
+//#region src/commands/manifest.d.ts
+declare class Manifest<T extends typeof Manifest> extends BaseCommand<T> {
+  static description: string;
+  static examples: string[];
+  static args: {
+    action: _oclif_core_interfaces11.Arg<string, Record<string, unknown>>;
+  };
+  static flags: {
+    framework: _oclif_core_interfaces11.OptionFlag<string | undefined, _oclif_core_interfaces11.CustomOptions>;
+    env: _oclif_core_interfaces11.OptionFlag<string, _oclif_core_interfaces11.CustomOptions>;
+    scope: _oclif_core_interfaces11.OptionFlag<string, _oclif_core_interfaces11.CustomOptions>;
+  };
+  run(): Promise<void>;
+  private runGenerate;
+  private runValidate;
+  private runClean;
+}
+//#endregion
+export { Manifest as default };

package/dist/commands/manifest.js

@@ -0,0 +1,108 @@
+import { getSourceFilename } from "../utils.js";
+import { BaseCommand } from "../baseCommand.js";
+import { debuglog } from "node:util";
+import { Args, Flags } from "@oclif/core";
+import { getFrameworkPath } from "@eggjs/utils";
+
+//#region src/commands/manifest.ts
+const debug = debuglog("egg/bin/commands/manifest");
+var Manifest = class extends BaseCommand {
+	static description = "Manage the startup manifest for faster cold starts";
+	static examples = [
+		"<%= config.bin %> <%= command.id %> generate",
+		"<%= config.bin %> <%= command.id %> generate --env=prod",
+		"<%= config.bin %> <%= command.id %> validate --env=prod",
+		"<%= config.bin %> <%= command.id %> clean"
+	];
+	static args = { action: Args.string({
+		required: true,
+		description: "Action to perform",
+		options: [
+			"generate",
+			"validate",
+			"clean"
+		]
+	}) };
+	static flags = {
+		framework: Flags.string({ description: "specify framework that can be absolute path or npm package" }),
+		env: Flags.string({
+			description: "server environment for manifest generation/validation",
+			default: "prod"
+		}),
+		scope: Flags.string({
+			description: "server scope for manifest validation",
+			default: ""
+		})
+	};
+	async run() {
+		const { action } = this.args;
+		switch (action) {
+			case "generate":
+				await this.runGenerate();
+				break;
+			case "validate":
+				await this.runValidate();
+				break;
+			case "clean":
+				await this.runClean();
+				break;
+		}
+	}
+	async runGenerate() {
+		const { flags } = this;
+		const framework = getFrameworkPath({
+			framework: flags.framework,
+			baseDir: flags.base
+		});
+		debug("generate manifest: baseDir=%s, framework=%s, env=%s, scope=%s", flags.base, framework, flags.env, flags.scope);
+		const options = {
+			baseDir: flags.base,
+			framework,
+			env: flags.env,
+			scope: flags.scope
+		};
+		const serverBin = getSourceFilename("../scripts/manifest-generate.mjs");
+		const args = [JSON.stringify(options)];
+		const execArgv = await this.buildRequiresExecArgv();
+		await this.forkNode(serverBin, args, { execArgv });
+	}
+	async runValidate() {
+		const { flags } = this;
+		debug("validate manifest: baseDir=%s, env=%s, scope=%s", flags.base, flags.env, flags.scope);
+		const savedEggManifest = process.env.EGG_MANIFEST;
+		process.env.EGG_MANIFEST = "true";
+		try {
+			const { ManifestStore } = await import("@eggjs/core");
+			const store = ManifestStore.load(flags.base, flags.env, flags.scope);
+			if (!store) {
+				console.error("[manifest] Manifest is invalid or does not exist");
+				return this.exit(1);
+			}
+			const { data } = store;
+			const resolveCacheCount = Object.keys(data.resolveCache ?? {}).length;
+			const fileDiscoveryCount = Object.keys(data.fileDiscovery ?? {}).length;
+			const extensionCount = Object.keys(data.extensions ?? {}).length;
+			console.log("[manifest] Manifest is valid");
+			console.log("[manifest]   version: %d", data.version);
+			console.log("[manifest]   generatedAt: %s", data.generatedAt);
+			console.log("[manifest]   serverEnv: %s", data.invalidation.serverEnv);
+			console.log("[manifest]   serverScope: %s", data.invalidation.serverScope);
+			console.log("[manifest]   resolveCache entries: %d", resolveCacheCount);
+			console.log("[manifest]   fileDiscovery entries: %d", fileDiscoveryCount);
+			console.log("[manifest]   extension entries: %d", extensionCount);
+		} finally {
+			if (savedEggManifest === void 0) delete process.env.EGG_MANIFEST;
+			else process.env.EGG_MANIFEST = savedEggManifest;
+		}
+	}
+	async runClean() {
+		const { flags } = this;
+		debug("clean manifest: baseDir=%s", flags.base);
+		const { ManifestStore } = await import("@eggjs/core");
+		ManifestStore.clean(flags.base);
+		console.log("[manifest] Manifest cleaned");
+	}
+};
+
+//#endregion
+export { Manifest as default };

package/dist/commands/test.d.ts

@@ -1,21 +1,22 @@
 import { BaseCommand } from "../baseCommand.js";
 import { InlineConfig } from "vitest/node";
-import * as _oclif_core_interfaces16 from "@oclif/core/interfaces";
+import * as _oclif_core_interfaces39 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_interfaces16.Arg<string | undefined, Record<string, unknown>>;
+    file: _oclif_core_interfaces39.Arg<string | undefined, Record<string, unknown>>;
   };
   static description: string;
   static examples: string[];
   static flags: {
-    bail: _oclif_core_interfaces16.BooleanFlag<boolean>;
-    timeout: _oclif_core_interfaces16.OptionFlag<number, _oclif_core_interfaces16.CustomOptions>;
-    'no-timeout': _oclif_core_interfaces16.BooleanFlag<boolean>;
-    grep: _oclif_core_interfaces16.OptionFlag<string | undefined, _oclif_core_interfaces16.CustomOptions>;
-    changed: _oclif_core_interfaces16.BooleanFlag<boolean>;
-    watch: _oclif_core_interfaces16.BooleanFlag<boolean>;
+    bail: _oclif_core_interfaces39.BooleanFlag<boolean>;
+    timeout: _oclif_core_interfaces39.OptionFlag<number, _oclif_core_interfaces39.CustomOptions>;
+    'no-timeout': _oclif_core_interfaces39.BooleanFlag<boolean>;
+    grep: _oclif_core_interfaces39.OptionFlag<string | undefined, _oclif_core_interfaces39.CustomOptions>;
+    changed: _oclif_core_interfaces39.BooleanFlag<boolean>;
+    watch: _oclif_core_interfaces39.BooleanFlag<boolean>;
+    pool: _oclif_core_interfaces39.OptionFlag<string, _oclif_core_interfaces39.CustomOptions>;
   };
   run(): Promise<void>;
   protected buildVitestConfig(files: string[]): Promise<InlineConfig>;

package/dist/commands/test.js

@@ -1,9 +1,9 @@
 import { BaseCommand, ForkError } from "../baseCommand.js";
 import path from "node:path";
 import { debuglog } from "node:util";
-import { EggType, ImportResolveError, detectType, importResolve } from "@eggjs/utils";
 import { Args, Flags } from "@oclif/core";
 import fs from "node:fs/promises";
+import { EggType, ImportResolveError, detectType, importResolve } from "@eggjs/utils";
 import ciParallelVars from "ci-parallel-vars";
 import globby from "globby";
 import { getChangedFilesForRoots } from "jest-changed-files";
@@ -45,6 +45,11 @@ var Test = class extends BaseCommand {
 			description: "run tests in watch mode",
 			default: false,
 			char: "w"
+		}),
+		pool: Flags.string({
+			description: "vitest worker pool type",
+			options: ["forks", "threads"],
+			default: process.env.EGG_VITEST_POOL ?? "threads"
 		})
 	};
 	async run() {
@@ -89,6 +94,8 @@ var Test = class extends BaseCommand {
 			return (path.isAbsolute(f) ? f : path.join(flags.base, f)).replace(/\\/g, "/");
 		});
 		process.env.EGG_BIN_TIMEOUT = String(flags.timeout);
+		process.env.EGG_VITEST_POOL = flags.pool;
+		process.env.EGG_VITEST_ISOLATE = process.env.EGG_VITEST_ISOLATE ?? "false";
 		debug("run test with vitest, files: %o, flags: %o", files, flags);
 		const config = await this.buildVitestConfig(files);
 		if (flags["dry-run"]) {
@@ -120,22 +127,24 @@ var Test = class extends BaseCommand {
 		setupFiles.push(...requires);
 		const eggType = await detectType(flags.base);
 		debug("eggType: %s", eggType);
-		if (eggType === EggType.application) try {
+		const isSelfTestFixture = !!process.env.EGG_BIN_SELF_TEST_FIXTURE;
+		if (!isSelfTestFixture && eggType === EggType.application) try {
 			const mockSetup = importResolve("@eggjs/mock/setup_vitest", { paths: [flags.base] });
 			setupFiles.push(mockSetup);
 			debug("auto add @eggjs/mock/setup_vitest: %o", mockSetup);
 		} catch (err) {
 			if (!(err instanceof ImportResolveError)) throw err;
-			debug("skip @eggjs/mock/setup_vitest: @eggjs/mock not installed");
+			debug("skip @eggjs/mock/setup_vitest: not resolvable");
 		}
 		let runner;
-		try {
-			runner = importResolve("@eggjs/tegg-vitest/runner", { paths: [flags.base] });
-			debug("auto use @eggjs/tegg-vitest/runner: %o", runner);
+		if (!isSelfTestFixture) for (const resolveFrom of [flags.base, import.meta.dirname]) try {
+			runner = importResolve("@eggjs/tegg-vitest/runner", { paths: [resolveFrom] });
+			debug("auto use @eggjs/tegg-vitest/runner from %s: %o", resolveFrom, runner);
+			break;
 		} catch (err) {
 			if (!(err instanceof ImportResolveError)) throw err;
-			debug("skip @eggjs/tegg-vitest/runner: @eggjs/tegg-vitest not installed");
 		}
+		if (!runner) debug("skip @eggjs/tegg-vitest/runner: self-test fixture or not resolvable");
 		return {
 			root: flags.base,
 			include: files,
@@ -145,12 +154,15 @@ var Test = class extends BaseCommand {
 				"**/node_modules/**"
 			],
 			testTimeout: flags.timeout,
+			hookTimeout: flags.timeout,
 			testNamePattern: flags.grep,
 			bail: flags.bail ? 1 : 0,
 			setupFiles,
 			runner,
 			reporters: [process.env.TEST_REPORTER ?? "default"],
-			pool: "forks",
+			pool: flags.pool,
+			isolate: process.env.EGG_VITEST_ISOLATE !== "false",
+			fileParallelism: process.env.EGG_FILE_PARALLELISM === "true",
 			execArgv: [...this.globalExecArgv],
 			watch: flags.watch,
 			globals: true,

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 import { PackageEgg } from "./types.js";
 import { BaseCommand, ForkError, ForkNodeOptions } from "./baseCommand.js";
+import Bundle from "./commands/bundle.js";
 import Test from "./commands/test.js";
 import Cov from "./commands/cov.js";
 import Dev from "./commands/dev.js";
+import Manifest from "./commands/manifest.js";
 export * from "@oclif/core";
-export { BaseCommand, Cov, Dev, ForkError, ForkNodeOptions, PackageEgg, Test };
+export { BaseCommand, Bundle, Cov, Dev, ForkError, ForkNodeOptions, Manifest, PackageEgg, Test };

package/dist/index.js

@@ -1,8 +1,10 @@
 import { BaseCommand, ForkError } from "./baseCommand.js";
+import Bundle from "./commands/bundle.js";
 import Test from "./commands/test.js";
 import Cov from "./commands/cov.js";
 import Dev from "./commands/dev.js";
+import Manifest from "./commands/manifest.js";
 
 export * from "@oclif/core"
 
-export { BaseCommand, Cov, Dev, ForkError, Test };
+export { BaseCommand, Bundle, Cov, Dev, ForkError, Manifest, Test };

package/dist/scripts/manifest-generate.mjs

@@ -0,0 +1,59 @@
+import { debuglog } from 'node:util';
+
+import { importModule } from '@eggjs/utils';
+
+const debug = debuglog('egg/bin/scripts/manifest-generate');
+
+async function main() {
+  debug('argv: %o', process.argv);
+  const options = JSON.parse(process.argv[2]);
+  debug('manifest generate options: %o', options);
+
+  // Set server env/scope before importing framework
+  if (options.env) {
+    process.env.EGG_SERVER_ENV = options.env;
+  }
+  if (options.scope) {
+    process.env.EGG_SERVER_SCOPE = options.scope;
+  }
+
+  // Clean any existing manifest before generation to ensure the collector
+  // captures all lookups (not just cache misses from a stale manifest).
+  const { ManifestStore } = await importModule('@eggjs/core', {
+    paths: [options.framework],
+  });
+  ManifestStore.clean(options.baseDir);
+
+  const framework = await importModule(options.framework);
+  const app = await framework.start({
+    baseDir: options.baseDir,
+    framework: options.framework,
+    env: options.env,
+    metadataOnly: true,
+  });
+
+  // Generate manifest from collected metadata
+  const manifest = app.loader.generateManifest();
+
+  // Write manifest to .egg/manifest.json
+  await ManifestStore.write(options.baseDir, manifest);
+
+  // Log stats
+  const resolveCacheCount = Object.keys(manifest.resolveCache).length;
+  const fileDiscoveryCount = Object.keys(manifest.fileDiscovery).length;
+  const extensionCount = Object.keys(manifest.extensions).length;
+  console.log('[manifest] Generated manifest v%d at %s', manifest.version, manifest.generatedAt);
+  console.log('[manifest]   resolveCache entries: %d', resolveCacheCount);
+  console.log('[manifest]   fileDiscovery entries: %d', fileDiscoveryCount);
+  console.log('[manifest]   extension entries: %d', extensionCount);
+  console.log('[manifest] Written to %s/.egg/manifest.json', options.baseDir);
+
+  // Clean up and exit
+  await app.close();
+  process.exit(0);
+}
+
+main().catch((err) => {
+  console.error('[manifest] Generation failed:', err);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eggjs/bin",
-  "version": "8.0.2-beta.1",
+  "version": "8.0.2-beta.10",
   "description": "egg developer tool",
   "homepage": "https://github.com/eggjs/egg/tree/next/tools/egg-bin",
   "bugs": {
@@ -28,8 +28,10 @@
   "exports": {
     ".": "./dist/index.js",
     "./baseCommand": "./dist/baseCommand.js",
+    "./commands/bundle": "./dist/commands/bundle.js",
     "./commands/cov": "./dist/commands/cov.js",
     "./commands/dev": "./dist/commands/dev.js",
+    "./commands/manifest": "./dist/commands/manifest.js",
     "./commands/test": "./dist/commands/test.js",
     "./types": "./dist/types.js",
     "./utils": "./dist/utils.js",
@@ -49,7 +51,10 @@
     "tsconfig-paths": "^4.2.0",
     "utility": "^2.5.0",
     "vitest": "^4.0.15",
-    "@eggjs/utils": "5.0.2-beta.1"
+    "@eggjs/tegg-vitest": "4.0.2-beta.10",
+    "@eggjs/core": "7.0.2-beta.10",
+    "@eggjs/utils": "5.0.2-beta.10",
+    "@eggjs/egg-bundler": "0.0.1-beta.0"
   },
   "devDependencies": {
     "@swc-node/register": "^1.11.1",
@@ -63,14 +68,15 @@
     "npminstall": "^7.12.0",
     "rimraf": "^6.1.2",
     "runscript": "^2.0.1",
+    "sdk-base": "^5.0.1",
     "typescript": "^5.9.3",
-    "@eggjs/mock": "7.0.2-beta.1",
-    "@eggjs/tsconfig": "3.1.2-beta.1",
-    "@eggjs/supertest": "9.0.2-beta.1",
-    "egg": "4.1.2-beta.1"
+    "@eggjs/mock": "7.0.2-beta.10",
+    "@eggjs/supertest": "9.0.2-beta.10",
+    "egg": "4.1.2-beta.10",
+    "@eggjs/tsconfig": "3.1.2-beta.10"
   },
   "peerDependencies": {
-    "@eggjs/mock": "7.0.2-beta.1"
+    "@eggjs/mock": "7.0.2-beta.10"
   },
   "peerDependenciesMeta": {
     "@eggjs/mock": {
@@ -90,8 +96,8 @@
     "node": ">=22.18.0"
   },
   "scripts": {
+    "build": "tsdown -c tsdown.config.ts",
     "typecheck": "tsgo --noEmit",
-    "pretest": "tsdown",
     "test": "vitest run",
     "cov": "vitest run --coverage",
     "ci": "npm run cov"

package/scripts/manifest-generate.mjs

@@ -0,0 +1,59 @@
+import { debuglog } from 'node:util';
+
+import { importModule } from '@eggjs/utils';
+
+const debug = debuglog('egg/bin/scripts/manifest-generate');
+
+async function main() {
+  debug('argv: %o', process.argv);
+  const options = JSON.parse(process.argv[2]);
+  debug('manifest generate options: %o', options);
+
+  // Set server env/scope before importing framework
+  if (options.env) {
+    process.env.EGG_SERVER_ENV = options.env;
+  }
+  if (options.scope) {
+    process.env.EGG_SERVER_SCOPE = options.scope;
+  }
+
+  // Clean any existing manifest before generation to ensure the collector
+  // captures all lookups (not just cache misses from a stale manifest).
+  const { ManifestStore } = await importModule('@eggjs/core', {
+    paths: [options.framework],
+  });
+  ManifestStore.clean(options.baseDir);
+
+  const framework = await importModule(options.framework);
+  const app = await framework.start({
+    baseDir: options.baseDir,
+    framework: options.framework,
+    env: options.env,
+    metadataOnly: true,
+  });
+
+  // Generate manifest from collected metadata
+  const manifest = app.loader.generateManifest();
+
+  // Write manifest to .egg/manifest.json
+  await ManifestStore.write(options.baseDir, manifest);
+
+  // Log stats
+  const resolveCacheCount = Object.keys(manifest.resolveCache).length;
+  const fileDiscoveryCount = Object.keys(manifest.fileDiscovery).length;
+  const extensionCount = Object.keys(manifest.extensions).length;
+  console.log('[manifest] Generated manifest v%d at %s', manifest.version, manifest.generatedAt);
+  console.log('[manifest]   resolveCache entries: %d', resolveCacheCount);
+  console.log('[manifest]   fileDiscovery entries: %d', fileDiscoveryCount);
+  console.log('[manifest]   extension entries: %d', extensionCount);
+  console.log('[manifest] Written to %s/.egg/manifest.json', options.baseDir);
+
+  // Clean up and exit
+  await app.close();
+  process.exit(0);
+}
+
+main().catch((err) => {
+  console.error('[manifest] Generation failed:', err);
+  process.exit(1);
+});