@eggjs/bin 7.0.0-beta.0

package/dist/esm/cmd/dev.js

@@ -0,0 +1,118 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { debuglog } from 'node:util';
+import { DefineCommand, Option } from '@artus-cli/artus-cli';
+import utils from '@eggjs/utils';
+import detect from 'detect-port';
+import { BaseCommand } from './base.js';
+import { getSourceFilename } from '../utils.js';
+const debug = debuglog('egg-bin:dev');
+let DevCommand = class DevCommand extends BaseCommand {
+    port;
+    workers;
+    framework;
+    sticky;
+    async run() {
+        debug('run dev: %o', this.ctx.args);
+        this.ctx.env.NODE_ENV = this.ctx.env.NODE_ENV ?? 'development';
+        this.ctx.env.EGG_MASTER_CLOSE_TIMEOUT = '1000';
+        const serverBin = getSourceFilename('../scripts/start-cluster.mjs');
+        const eggStartOptions = await this.formatEggStartOptions();
+        const args = [JSON.stringify(eggStartOptions)];
+        const requires = await this.formatRequires();
+        const execArgv = [];
+        for (const r of requires) {
+            execArgv.push('--require');
+            execArgv.push(r);
+        }
+        await this.forkNode(serverBin, args, { execArgv });
+    }
+    async formatEggStartOptions() {
+        this.framework = utils.getFrameworkPath({
+            framework: this.framework,
+            baseDir: this.base,
+        });
+        if (!this.port) {
+            let configuredPort;
+            try {
+                const configuration = await utils.getConfig({
+                    framework: this.framework,
+                    baseDir: this.base,
+                    env: 'local',
+                });
+                configuredPort = configuration?.cluster?.listen?.port;
+            }
+            catch (err) {
+                /** skip when failing to read the configuration */
+                debug('getConfig error: %s, framework: %o, baseDir: %o, env: local', err, this.framework, this.base);
+            }
+            if (configuredPort) {
+                this.port = configuredPort;
+                debug(`use port ${this.port} from configuration file`);
+            }
+            else {
+                const defaultPort = process.env.EGG_BIN_DEFAULT_PORT ?? 7001;
+                debug('detect available port');
+                this.port = await detect(defaultPort);
+                if (this.port !== defaultPort) {
+                    console.warn('[egg-bin] server port %s is in use, now using port %o', defaultPort, this.port);
+                }
+                debug(`use available port ${this.port}`);
+            }
+        }
+        return {
+            baseDir: this.base,
+            workers: this.workers,
+            port: this.port,
+            framework: this.framework,
+            typescript: this.ctx.args.typescript,
+            tscompiler: this.ctx.args.tscompiler,
+            sticky: this.sticky,
+        };
+    }
+};
+__decorate([
+    Option({
+        description: 'listening port, default to 7001',
+        alias: 'p',
+    }),
+    __metadata("design:type", Number)
+], DevCommand.prototype, "port", void 0);
+__decorate([
+    Option({
+        description: 'numbers of app workers, default to 1 at local mode',
+        alias: ['c', 'cluster'],
+        default: 1,
+    }),
+    __metadata("design:type", Number)
+], DevCommand.prototype, "workers", void 0);
+__decorate([
+    Option({
+        description: 'specify framework that can be absolute path or npm package, default is egg',
+    }),
+    __metadata("design:type", String)
+], DevCommand.prototype, "framework", void 0);
+__decorate([
+    Option({
+        description: 'start a sticky cluster server, default to false',
+        type: 'boolean',
+        default: false,
+    }),
+    __metadata("design:type", Boolean)
+], DevCommand.prototype, "sticky", void 0);
+DevCommand = __decorate([
+    DefineCommand({
+        command: 'dev',
+        description: 'Start server at local dev mode',
+        alias: ['d'],
+    })
+], DevCommand);
+export { DevCommand };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/cmd/test.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from './base.js';
+export declare class TestCommand extends BaseCommand {
+    files: string[];
+    timeout: number | boolean;
+    grep: string[];
+    changed: boolean;
+    parallel: boolean;
+    jobs: number;
+    autoAgent: boolean;
+    mochawesome: boolean;
+    bail: boolean;
+    run(): Promise<void>;
+    protected formatMochaArgs(): Promise<string[] | undefined>;
+    protected getChangedTestFiles(dir: string, ext: string): Promise<string[]>;
+}

package/dist/esm/cmd/test.js

@@ -0,0 +1,237 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { debuglog } from 'node:util';
+import os from 'node:os';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { DefineCommand, Option, } from '@artus-cli/artus-cli';
+import globby from 'globby';
+import { importResolve } from '@eggjs/utils';
+import { getChangedFilesForRoots } from 'jest-changed-files';
+import { BaseCommand } from './base.js';
+const debug = debuglog('egg-bin:test');
+let TestCommand = class TestCommand extends BaseCommand {
+    files;
+    timeout;
+    grep;
+    changed;
+    parallel;
+    jobs;
+    autoAgent;
+    mochawesome;
+    bail;
+    async run() {
+        try {
+            await fs.access(this.base);
+        }
+        catch (err) {
+            console.error('baseDir: %o not exists', this.base);
+            throw err;
+        }
+        const mochaFile = process.env.MOCHA_FILE || importResolve('mocha/bin/_mocha');
+        if (this.parallel) {
+            this.ctx.env.ENABLE_MOCHA_PARALLEL = 'true';
+            if (this.autoAgent) {
+                this.ctx.env.AUTO_AGENT = 'true';
+            }
+        }
+        // set NODE_ENV=test, let egg application load unittest logic
+        // https://eggjs.org/basics/env#difference-from-node_env
+        this.ctx.env.NODE_ENV = 'test';
+        debug('run test: %s %o', mochaFile, this.ctx.args);
+        const mochaArgs = await this.formatMochaArgs();
+        if (!mochaArgs)
+            return;
+        await this.forkNode(mochaFile, mochaArgs, {
+            execArgv: [
+                ...process.execArgv,
+                // https://github.com/mochajs/mocha/issues/2640#issuecomment-1663388547
+                '--unhandled-rejections=strict',
+            ],
+        });
+    }
+    async formatMochaArgs() {
+        // collect require
+        const requires = await this.formatRequires();
+        try {
+            const eggMockRegister = importResolve('@eggjs/mock/register', { paths: [this.base] });
+            requires.push(eggMockRegister);
+            debug('auto register @eggjs/mock/register: %o', eggMockRegister);
+        }
+        catch (err) {
+            // ignore @eggjs/mock not exists
+            debug('auto register @eggjs/mock fail, can not require @eggjs/mock on %o, error: %s', this.base, err.message);
+        }
+        // handle mochawesome enable
+        let reporter = this.ctx.env.TEST_REPORTER;
+        let reporterOptions = '';
+        if (!reporter && this.mochawesome) {
+            // use https://github.com/node-modules/mochawesome/pull/1 instead
+            reporter = importResolve('mochawesome-with-mocha');
+            reporterOptions = 'reportDir=node_modules/.mochawesome-reports';
+            if (this.parallel) {
+                // https://github.com/adamgruber/mochawesome#parallel-mode
+                requires.push(importResolve('mochawesome-with-mocha/register'));
+            }
+        }
+        const ext = this.ctx.args.typescript ? 'ts' : 'js';
+        let pattern = this.files;
+        // changed
+        if (this.changed) {
+            pattern = await this.getChangedTestFiles(this.base, ext);
+            if (!pattern.length) {
+                console.log('No changed test files');
+                return;
+            }
+            debug('changed files: %o', pattern);
+        }
+        if (!pattern.length && process.env.TESTS) {
+            pattern = process.env.TESTS.split(',');
+        }
+        // collect test files when nothing is changed
+        if (!pattern.length) {
+            pattern = [`test/**/*.test.${ext}`];
+        }
+        pattern = pattern.concat(['!test/fixtures', '!test/node_modules']);
+        // expand glob and skip node_modules and fixtures
+        const files = globby.sync(pattern, { cwd: this.base });
+        files.sort();
+        if (files.length === 0) {
+            console.log(`No test files found with ${pattern}`);
+            return;
+        }
+        // auto add setup file as the first test file
+        const setupFile = path.join(this.base, `test/.setup.${ext}`);
+        try {
+            await fs.access(setupFile);
+            files.unshift(setupFile);
+        }
+        catch {
+            // ignore
+        }
+        return [
+            this.dryRun ? '--dry-run' : '',
+            // force exit
+            '--exit',
+            this.bail ? '--bail' : '',
+            this.grep.map(pattern => `--grep='${pattern}'`).join(' '),
+            this.timeout === false ? '--no-timeout' : `--timeout=${this.timeout}`,
+            this.parallel ? '--parallel' : '',
+            this.parallel && this.jobs ? `--jobs=${this.jobs}` : '',
+            reporter ? `--reporter=${reporter}` : '',
+            reporterOptions ? `--reporter-options=${reporterOptions}` : '',
+            ...requires.map(r => `--require=${r}`),
+            ...files,
+        ].filter(a => a.trim());
+    }
+    async getChangedTestFiles(dir, ext) {
+        const res = await getChangedFilesForRoots([path.join(dir, 'test')], {});
+        const changedFiles = res.changedFiles;
+        const files = [];
+        for (let cf of changedFiles) {
+            // only find test/**/*.test.(js|ts)
+            if (cf.endsWith(`.test.${ext}`)) {
+                // Patterns MUST use forward slashes (not backslashes)
+                // This should be converted on Windows
+                if (process.platform === 'win32') {
+                    cf = cf.replace(/\\/g, '/');
+                }
+                files.push(cf);
+            }
+        }
+        return files;
+    }
+};
+__decorate([
+    Option({
+        default: [],
+        array: true,
+        type: 'string',
+    }),
+    __metadata("design:type", Array)
+], TestCommand.prototype, "files", void 0);
+__decorate([
+    Option({
+        description: 'set test-case timeout in milliseconds, default is 60000',
+        alias: 't',
+        default: process.env.TEST_TIMEOUT ?? 60000,
+    }),
+    __metadata("design:type", Object)
+], TestCommand.prototype, "timeout", void 0);
+__decorate([
+    Option({
+        description: 'only run tests matching <pattern>',
+        alias: 'g',
+        type: 'string',
+        array: true,
+        default: [],
+    }),
+    __metadata("design:type", Array)
+], TestCommand.prototype, "grep", void 0);
+__decorate([
+    Option({
+        description: 'only test with changed files and match test/**/*.test.(js|ts), default is false',
+        alias: 'c',
+        type: 'boolean',
+        default: false,
+    }),
+    __metadata("design:type", Boolean)
+], TestCommand.prototype, "changed", void 0);
+__decorate([
+    Option({
+        description: 'mocha parallel mode, default is false',
+        alias: 'p',
+        type: 'boolean',
+        default: false,
+    }),
+    __metadata("design:type", Boolean)
+], TestCommand.prototype, "parallel", void 0);
+__decorate([
+    Option({
+        description: 'number of jobs to run in parallel',
+        type: 'number',
+        default: os.cpus().length - 1,
+    }),
+    __metadata("design:type", Number)
+], TestCommand.prototype, "jobs", void 0);
+__decorate([
+    Option({
+        description: 'auto bootstrap agent in mocha master process, default is true',
+        type: 'boolean',
+        default: true,
+    }),
+    __metadata("design:type", Boolean)
+], TestCommand.prototype, "autoAgent", void 0);
+__decorate([
+    Option({
+        description: 'enable mochawesome reporter, default is true',
+        type: 'boolean',
+        default: true,
+    }),
+    __metadata("design:type", Boolean)
+], TestCommand.prototype, "mochawesome", void 0);
+__decorate([
+    Option({
+        description: 'bbort ("bail") after first test failure',
+        alias: 'b',
+        type: 'boolean',
+        default: false,
+    }),
+    __metadata("design:type", Boolean)
+], TestCommand.prototype, "bail", void 0);
+TestCommand = __decorate([
+    DefineCommand({
+        command: 'test [files...]',
+        description: 'Run the test',
+        alias: ['t'],
+    })
+], TestCommand);
+export { TestCommand };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.js","sourceRoot":"","sources":["../../../src/cmd/test.ts"],"names":[],"mappings":"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"}

package/dist/esm/config/framework.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    package: string;
+};
+export default _default;

package/dist/esm/config/framework.js

@@ -0,0 +1,4 @@
+export default {
+    package: '@artus-cli/artus-cli',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnJhbWV3b3JrLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbmZpZy9mcmFtZXdvcmsudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsZUFBZTtJQUNiLE9BQU8sRUFBRSxzQkFBc0I7Q0FDaEMsQ0FBQyJ9

package/dist/esm/config/plugin.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+    autocomplete: {
+        enable: boolean;
+        package: string;
+    };
+    version: {
+        enable: boolean;
+        package: string;
+    };
+};
+export default _default;

package/dist/esm/config/plugin.js

@@ -0,0 +1,11 @@
+export default {
+    autocomplete: {
+        enable: true,
+        package: '@artus-cli/plugin-autocomplete',
+    },
+    version: {
+        enable: true,
+        package: '@artus-cli/plugin-version',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbmZpZy9wbHVnaW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsZUFBZTtJQUNiLFlBQVksRUFBRTtRQUNaLE1BQU0sRUFBRSxJQUFJO1FBQ1osT0FBTyxFQUFFLGdDQUFnQztLQUMxQztJQUNELE9BQU8sRUFBRTtRQUNQLE1BQU0sRUFBRSxJQUFJO1FBQ1osT0FBTyxFQUFFLDJCQUEyQjtLQUNyQztDQUNGLENBQUMifQ==

package/dist/esm/index.d.ts

@@ -0,0 +1,5 @@
+export * from './cmd/dev.js';
+export * from './cmd/debug.js';
+export * from './cmd/test.js';
+export * from './cmd/cov.js';
+export * from './cmd/base.js';

package/dist/esm/index.js

@@ -0,0 +1,6 @@
+export * from './cmd/dev.js';
+export * from './cmd/debug.js';
+export * from './cmd/test.js';
+export * from './cmd/cov.js';
+export * from './cmd/base.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGVBQWUsQ0FBQyJ9

package/dist/esm/middleware/global_options.d.ts

@@ -0,0 +1,5 @@
+import { ApplicationLifecycle } from '@artus-cli/artus-cli';
+export default class GlobalOptions implements ApplicationLifecycle {
+    private readonly program;
+    configDidLoad(): Promise<void>;
+}

package/dist/esm/middleware/global_options.js

@@ -0,0 +1,182 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { debuglog } from 'node:util';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { Inject, LifecycleHook, LifecycleHookUnit, Program, } from '@artus-cli/artus-cli';
+import { importResolve } from '@eggjs/utils';
+import { runScript } from 'runscript';
+import { addNodeOptionsToEnv, getSourceDirname, readPackageJSON, hasTsConfig, getSourceFilename, } from '../utils.js';
+const debug = debuglog('@eggjs/bin/middleware/global_options');
+let GlobalOptions = class GlobalOptions {
+    program;
+    async configDidLoad() {
+        // add global options
+        this.program.option({
+            base: {
+                description: 'directory of application, default to `process.cwd()`',
+                type: 'string',
+                alias: 'baseDir',
+            },
+            declarations: {
+                description: 'whether create typings, will add `--require egg-ts-helper/register`',
+                type: 'boolean',
+                alias: 'dts',
+            },
+            typescript: {
+                description: 'whether enable typescript support',
+                type: 'boolean',
+                alias: 'ts',
+            },
+            tscompiler: {
+                description: 'ts compiler, like ts-node/register, ts-node/register/transpile-only, @swc-node/register, esbuild-register etc',
+                type: 'string',
+                alias: 'tsc',
+            },
+        });
+        this.program.use(async (ctx, next) => {
+            debug('before next');
+            if (!ctx.args.base) {
+                ctx.args.base = ctx.cwd;
+                debug('ctx.args.base not set, auto set it to cwd: %o', ctx.cwd);
+            }
+            if (!path.isAbsolute(ctx.args.base)) {
+                ctx.args.base = path.join(ctx.cwd, ctx.args.base);
+            }
+            debug('matched cmd: %o, ctx.args.base: %o', ctx.matched?.cmd, ctx.args.base);
+            const pkg = await readPackageJSON(ctx.args.base);
+            ctx.args.pkgEgg = pkg.egg ?? {};
+            const tscompiler = ctx.args.tscompiler ?? ctx.env.TS_COMPILER ?? ctx.args.pkgEgg.tscompiler;
+            if (ctx.args.typescript === undefined) {
+                // try to ready EGG_TYPESCRIPT env first, only accept 'true' or 'false' string
+                if (ctx.env.EGG_TYPESCRIPT === 'false') {
+                    ctx.args.typescript = false;
+                    debug('detect typescript=%o from EGG_TYPESCRIPT=%o', false, ctx.env.EGG_TYPESCRIPT);
+                }
+                else if (ctx.env.EGG_TYPESCRIPT === 'true') {
+                    ctx.args.typescript = true;
+                    debug('detect typescript=%o from EGG_TYPESCRIPT=%o', true, ctx.env.EGG_TYPESCRIPT);
+                }
+                else if (typeof ctx.args.pkgEgg.typescript === 'boolean') {
+                    // read `egg.typescript` from package.json if not pass argv
+                    ctx.args.typescript = ctx.args.pkgEgg.typescript;
+                    debug('detect typescript=%o from pkg.egg.typescript=%o', true, ctx.args.pkgEgg.typescript);
+                }
+                else if (pkg.dependencies?.typescript) {
+                    // auto detect pkg.dependencies.typescript or pkg.devDependencies.typescript
+                    ctx.args.typescript = true;
+                    debug('detect typescript=%o from pkg.dependencies.typescript=%o', true, pkg.dependencies.typescript);
+                }
+                else if (pkg.devDependencies?.typescript) {
+                    ctx.args.typescript = true;
+                    debug('detect typescript=%o from pkg.devDependencies.typescript=%o', true, pkg.devDependencies.typescript);
+                }
+                else if (await hasTsConfig(ctx.args.base)) {
+                    // tsconfig.json exists
+                    ctx.args.typescript = true;
+                    debug('detect typescript=%o cause tsconfig.json exists', true);
+                }
+                else if (tscompiler) {
+                    ctx.args.typescript = true;
+                    debug('detect typescript=%o from --tscompiler=%o', true, tscompiler);
+                }
+            }
+            const isESM = pkg.type === 'module';
+            if (ctx.args.typescript) {
+                const findPaths = [getSourceFilename('middleware')];
+                if (tscompiler) {
+                    // try app baseDir first on custom tscompiler
+                    findPaths.unshift(ctx.args.base);
+                }
+                ctx.args.tscompiler = tscompiler ?? 'ts-node/register';
+                const tsNodeRegister = importResolve(ctx.args.tscompiler, {
+                    paths: findPaths,
+                });
+                // should require tsNodeRegister on current process, let it can require *.ts files
+                // e.g.: dev command will execute egg loader to find configs and plugins
+                // await importModule(tsNodeRegister);
+                // let child process auto require ts-node too
+                if (isESM) {
+                    addNodeOptionsToEnv(`--import ${tsNodeRegister}`, ctx.env);
+                }
+                else {
+                    addNodeOptionsToEnv(`--require ${tsNodeRegister}`, ctx.env);
+                }
+                // addNodeOptionsToEnv(`--require ${tsNodeRegister}`, ctx.env);
+                // tell egg loader to load ts file
+                // see https://github.com/eggjs/egg-core/blob/master/lib/loader/egg_loader.js#L443
+                ctx.env.EGG_TYPESCRIPT = 'true';
+                // set current process.env.EGG_TYPESCRIPT too
+                process.env.EGG_TYPESCRIPT = 'true';
+                // load files from tsconfig on startup
+                ctx.env.TS_NODE_FILES = process.env.TS_NODE_FILES ?? 'true';
+                // keep same logic with egg-core, test cmd load files need it
+                // see https://github.com/eggjs/egg-core/blob/master/lib/loader/egg_loader.js#L49
+                // addNodeOptionsToEnv(`--require ${importResolve('tsconfig-paths/register', {
+                //   paths: [ getSourceDirname() ],
+                // })}`, ctx.env);
+            }
+            if (isESM) {
+                // use ts-node/esm loader on esm
+                let esmLoader = importResolve('ts-node/esm', {
+                    paths: [getSourceDirname()],
+                });
+                if (process.platform === 'win32') {
+                    // ES Module loading with absolute path fails on windows
+                    // https://github.com/nodejs/node/issues/31710#issuecomment-583916239
+                    // https://nodejs.org/api/url.html#url_url_pathtofileurl_path
+                    esmLoader = pathToFileURL(esmLoader).href;
+                }
+                // wait for https://github.com/nodejs/node/issues/40940
+                addNodeOptionsToEnv('--no-warnings', ctx.env);
+                addNodeOptionsToEnv(`--loader ${esmLoader}`, ctx.env);
+            }
+            if (ctx.args.declarations === undefined) {
+                if (typeof ctx.args.pkgEgg.declarations === 'boolean') {
+                    // read `egg.declarations` from package.json if not pass argv
+                    ctx.args.declarations = ctx.args.pkgEgg.declarations;
+                    debug('detect declarations from pkg.egg.declarations=%o', ctx.args.pkgEgg.declarations);
+                }
+            }
+            if (ctx.args.declarations) {
+                const etsBin = importResolve('egg-ts-helper/dist/bin');
+                debug('run ets first: %o', etsBin);
+                await runScript(`node ${etsBin}`);
+            }
+            if (ctx.args.pkgEgg.revert) {
+                ctx.args.execArgv = ctx.args.execArgv || [];
+                const reverts = Array.isArray(ctx.args.pkgEgg.revert) ? ctx.args.pkgEgg.revert : [ctx.args.pkgEgg.revert];
+                for (const revert of reverts) {
+                    ctx.args.execArgv.push(`--security-revert=${revert}`);
+                }
+            }
+            debug('set NODE_OPTIONS: %o', ctx.env.NODE_OPTIONS);
+            debug('ctx.args: %o', ctx.args);
+            debug('enter next');
+            await next();
+            debug('after next');
+        });
+    }
+};
+__decorate([
+    Inject(),
+    __metadata("design:type", Program)
+], GlobalOptions.prototype, "program", void 0);
+__decorate([
+    LifecycleHook(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], GlobalOptions.prototype, "configDidLoad", null);
+GlobalOptions = __decorate([
+    LifecycleHookUnit()
+], GlobalOptions);
+export default GlobalOptions;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"global_options.js","sourceRoot":"","sources":["../../../src/middleware/global_options.ts"],"names":[],"mappings":"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"}

package/dist/esm/middleware/handle_error.d.ts

@@ -0,0 +1,5 @@
+import { ApplicationLifecycle } from '@artus-cli/artus-cli';
+export default class implements ApplicationLifecycle {
+    private readonly program;
+    configDidLoad(): Promise<void>;
+}