@eggjs/bin 7.0.0-beta.3 → 7.0.0

package/dist/esm/baseCommand.js

@@ -0,0 +1,362 @@
+import { debuglog } from 'node:util';
+import { pathToFileURL } from 'node:url';
+import path from 'node:path';
+import { fork } from 'node:child_process';
+import { Command, Flags } from '@oclif/core';
+import { importResolve } from '@eggjs/utils';
+import { runScript } from 'runscript';
+import { getSourceDirname, readPackageJSON, hasTsConfig, } from './utils.js';
+const debug = debuglog('@eggjs/bin/baseCommand');
+// only hook once and only when ever start any child.
+const children = new Set();
+let hadHook = false;
+function graceful(proc) {
+    // save child ref
+    children.add(proc);
+    // only hook once
+    /* 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);
+            }
+        });
+    }
+}
+export class ForkError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+export class BaseCommand extends Command {
+    // add the --json flag
+    static enableJsonFlag = false;
+    // define flags that can be inherited by any command that extends BaseCommand
+    static baseFlags = {
+        // 'log-level': Flags.option({
+        //   default: 'info',
+        //   helpGroup: 'GLOBAL',
+        //   options: ['debug', 'warn', 'error', 'info', 'trace'] as const,
+        //   summary: 'Specify level for logging.',
+        // })(),
+        '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'],
+        }),
+        // flag with no value (--typescript)
+        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'],
+        }),
+        // https://nodejs.org/dist/latest-v18.x/docs/api/cli.html#--inspect-brkhostport
+        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;
+        // keep compatible with old ts flag: `--ts=true` or `--ts=false`
+        if (flags.ts === 'true') {
+            typescript = true;
+        }
+        else if (flags.ts === 'false') {
+            typescript = false;
+        }
+        if (typescript === undefined) {
+            // try to ready EGG_TYPESCRIPT env first, only accept 'true' or 'false' string
+            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') {
+                // read `egg.typescript` from package.json if not pass argv
+                typescript = this.pkgEgg.typescript;
+                debug('detect typescript=%o from pkg.egg.typescript=%o', typescript, this.pkgEgg.typescript);
+            }
+            else if (pkg.dependencies?.typescript) {
+                // auto detect pkg.dependencies.typescript or pkg.devDependencies.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)) {
+                // tsconfig.json exists
+                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;
+        this.isESM = pkg.type === 'module';
+        if (typescript) {
+            const findPaths = [getSourceDirname()];
+            if (flags.tscompiler) {
+                // try app baseDir first on custom tscompiler
+                // then try to find tscompiler in @eggjs/bin/node_modules
+                findPaths.unshift(flags.base);
+            }
+            flags.tscompiler = flags.tscompiler ?? 'ts-node/register';
+            const tsNodeRegister = importResolve(flags.tscompiler, {
+                paths: findPaths,
+            });
+            flags.tscompiler = tsNodeRegister;
+            // 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
+            this.addNodeOptions(this.formatImportModule(tsNodeRegister));
+            // tell egg loader to load ts file
+            // see https://github.com/eggjs/egg-core/blob/master/lib/loader/egg_loader.js#L443
+            this.env.EGG_TYPESCRIPT = 'true';
+            // set current process.env.EGG_TYPESCRIPT too
+            process.env.EGG_TYPESCRIPT = 'true';
+            // load files from tsconfig on startup
+            this.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 (this.isESM) {
+            // use ts-node/esm loader on esm
+            let esmLoader = importResolve('ts-node/esm', {
+                paths: [getSourceDirname()],
+            });
+            // 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
+            // Error [ERR_UNSUPPORTED_ESM_URL_SCHEME]: Only URLs with a scheme in: file, data, and node are supported by the default ESM loader. On Windows, absolute paths must be valid file:// URLs. Received protocol 'd:'
+            esmLoader = pathToFileURL(esmLoader).href;
+            // wait for https://github.com/nodejs/node/issues/40940
+            this.addNodeOptions('--no-warnings');
+            this.addNodeOptions(`--loader ${esmLoader}`);
+        }
+        if (flags.declarations === undefined) {
+            if (typeof this.pkgEgg.declarations === 'boolean') {
+                // read `egg.declarations` from package.json if not pass argv
+                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: [
+                    flags.base,
+                    getSourceDirname(),
+                ],
+            });
+            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) {
+            // others like WebStorm 2019 will pass NODE_OPTIONS, and @eggjs/bin itself will be debug, so could detect `process.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) {
+        // add any custom logic to handle errors from the command
+        // or simply return the parent class error handling
+        return super.catch(err);
+    }
+    async finally(_) {
+        // called after run and catch regardless of whether or not the command errored
+        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}`;
+        }
+        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();
+                }
+            });
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"baseCommand.js","sourceRoot":"","sources":["../../src/baseCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,IAAI,EAA6B,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAc,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EACL,gBAAgB,EAChB,eAAe,EAAE,WAAW,GAC7B,MAAM,YAAY,CAAC;AAGpB,MAAM,KAAK,GAAG,QAAQ,CAAC,wBAAwB,CAAC,CAAC;AAEjD,qDAAqD;AACrD,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAgB,CAAC;AACzC,IAAI,OAAO,GAAG,KAAK,CAAC;AACpB,SAAS,QAAQ,CAAC,IAAkB;IAClC,iBAAiB;IACjB,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAEnB,iBAAiB;IACjB,oBAAoB;IACpB,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,GAAG,IAAI,CAAC;QACf,IAAI,MAAsB,CAAC;QAC3B,CAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,CAAE,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACjD,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE;gBACvB,MAAM,GAAG,KAAuB,CAAC;gBACjC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAClB,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,IAAY,EAAE,EAAE;YACpC,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;gBAC7B,KAAK,CAAC,8CAA8C,EAAE,IAAI,EAAE,KAAK,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;gBAC/E,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACrB,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;AACH,CAAC;AAED,MAAM,OAAO,SAAU,SAAQ,KAAK;IAClC,IAAI,CAAgB;IACpB,YAAY,OAAe,EAAE,IAAmB;QAC9C,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AASD,MAAM,OAAgB,WAAsC,SAAQ,OAAO;IACzE,sBAAsB;IACtB,MAAM,CAAC,cAAc,GAAG,KAAK,CAAC;IAE9B,6EAA6E;IAC7E,MAAM,CAAC,SAAS,GAAG;QACjB,8BAA8B;QAC9B,qBAAqB;QACrB,yBAAyB;QACzB,mEAAmE;QACnE,2CAA2C;QAC3C,QAAQ;QACR,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC;YACvB,OAAO,EAAE,KAAK;YACd,SAAS,EAAE,QAAQ;YACnB,OAAO,EAAE,uCAAuC;YAChD,IAAI,EAAE,GAAG;SACV,CAAC;QACF,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC;YACpB,SAAS,EAAE,QAAQ;YACnB,OAAO,EAAE,0BAA0B;YACnC,IAAI,EAAE,GAAG;YACT,QAAQ,EAAE,IAAI;SACf,CAAC;QACF,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC;YACnB,SAAS,EAAE,QAAQ;YACnB,OAAO,EAAE,2CAA2C;YACpD,QAAQ,EAAE,IAAI;SACf,CAAC;QACF,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC;YACjB,SAAS,EAAE,QAAQ;YACnB,OAAO,EAAE,0BAA0B;YACnC,OAAO,EAAE,CAAE,SAAS,CAAE;YACtB,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE;SACvB,CAAC;QACF,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC;YACvB,SAAS,EAAE,QAAQ;YACnB,OAAO,EAAE,4CAA4C;YACrD,OAAO,EAAE,CAAE,KAAK,CAAE;SACnB,CAAC;QACF,oCAAoC;QACpC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC;YACxB,SAAS,EAAE,QAAQ;YACnB,WAAW,EAAE,gDAAgD;YAC7D,OAAO,EAAE,IAAI;SACd,CAAC;QACF,EAAE,EAAE,KAAK,CAAC,MAAM,CAAC;YACf,SAAS,EAAE,QAAQ;YACnB,WAAW,EAAE,6CAA6C;YAC1D,OAAO,EAAE,CAAE,MAAM,EAAE,OAAO,CAAE;SAC7B,CAAC;QACF,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC;YACxB,SAAS,EAAE,QAAQ;YACnB,WAAW,EAAE,gCAAgC;YAC7C,OAAO,EAAE,CAAE,IAAI,CAAE;SAClB,CAAC;QACF,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC;YAC1B,SAAS,EAAE,QAAQ;YACnB,WAAW,EAAE,qEAAqE;YAClF,OAAO,EAAE,CAAE,KAAK,CAAE;SACnB,CAAC;QACF,+EAA+E;QAC/E,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC;YACrB,SAAS,EAAE,QAAQ;YACnB,WAAW,EAAE,oBAAoB;SAClC,CAAC;QACF,aAAa,EAAE,KAAK,CAAC,OAAO,CAAC;YAC3B,SAAS,EAAE,QAAQ;YACnB,WAAW,EAAE,sDAAsD;SACpE,CAAC;KACH,CAAC;IAEQ,KAAK,CAAY;IACjB,IAAI,CAAW;IAEf,GAAG,GAAG,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;IACzB,GAAG,CAAsB;IACzB,KAAK,CAAU;IACf,MAAM,CAAa;IACnB,cAAc,GAAa,EAAE,CAAC;IAEjC,KAAK,CAAC,IAAI;QACf,MAAM,KAAK,CAAC,IAAI,EAAE,CAAC;QACnB,KAAK,CAAC,mCAAmC,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACzE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC;YACvC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK;YACtB,SAAS,EAAG,KAAK,CAAC,IAA2B,CAAC,SAAS;YACvD,cAAc,EAAE,IAAI,CAAC,IAAI,CAAC,cAAc;YACxC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI;YACpB,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM;SACzB,CAAC,CAAC;QACH,IAAI,CAAC,KAAK,GAAG,KAAiB,CAAC;QAC/B,IAAI,CAAC,IAAI,GAAG,IAAe,CAAC;QAE5B,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;IAC1B,CAAC;IAED,KAAK,CAAC,UAAU;QACd,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC;QAC7B,KAAK,CAAC,6BAA6B,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QAClD,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YACjC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;QACpD,CAAC;QACD,MAAM,GAAG,GAAG,MAAM,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC9C,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC;QAC5B,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,IAAI,IAAI,CAAC,GAAG,CAAC,WAAW,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;QAEtF,IAAI,UAAU,GAAY,KAAK,CAAC,UAAU,CAAC;QAC3C,gEAAgE;QAChE,IAAI,KAAK,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;YACxB,UAAU,GAAG,IAAI,CAAC;QACpB,CAAC;aAAM,IAAI,KAAK,CAAC,EAAE,KAAK,OAAO,EAAE,CAAC;YAChC,UAAU,GAAG,KAAK,CAAC;QACrB,CAAC;QAED,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC7B,8EAA8E;YAC9E,IAAI,IAAI,CAAC,GAAG,CAAC,cAAc,KAAK,OAAO,EAAE,CAAC;gBACxC,UAAU,GAAG,KAAK,CAAC;gBACnB,KAAK,CAAC,6CAA6C,EAAE,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;YACvF,CAAC;iBAAM,IAAI,IAAI,CAAC,GAAG,CAAC,cAAc,KAAK,MAAM,EAAE,CAAC;gBAC9C,UAAU,GAAG,IAAI,CAAC;gBAClB,KAAK,CAAC,6CAA6C,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;YACtF,CAAC;iBAAM,IAAI,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;gBACvD,2DAA2D;gBAC3D,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;gBACpC,KAAK,CAAC,iDAAiD,EAAE,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;YAC/F,CAAC;iBAAM,IAAI,GAAG,CAAC,YAAY,EAAE,UAAU,EAAE,CAAC;gBACxC,4EAA4E;gBAC5E,UAAU,GAAG,IAAI,CAAC;gBAClB,KAAK,CAAC,0DAA0D,EAAE,IAAI,EAAE,GAAG,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;YACvG,CAAC;iBAAM,IAAI,GAAG,CAAC,eAAe,EAAE,UAAU,EAAE,CAAC;gBAC3C,UAAU,GAAG,IAAI,CAAC;gBAClB,KAAK,CAAC,6DAA6D,EAAE,IAAI,EAAE,GAAG,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;YAC7G,CAAC;iBAAM,IAAI,MAAM,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;gBACzC,uBAAuB;gBACvB,UAAU,GAAG,IAAI,CAAC;gBAClB,KAAK,CAAC,iDAAiD,EAAE,IAAI,CAAC,CAAC;YACjE,CAAC;iBAAM,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;gBAC5B,UAAU,GAAG,IAAI,CAAC;gBAClB,KAAK,CAAC,2CAA2C,EAAE,IAAI,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;YAC7E,CAAC;QACH,CAAC;QACD,KAAK,CAAC,UAAU,GAAG,UAAU,CAAC;QAE9B,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC,IAAI,KAAK,QAAQ,CAAC;QACnC,IAAI,UAAU,EAAE,CAAC;YACf,MAAM,SAAS,GAAa,CAAE,gBAAgB,EAAE,CAAE,CAAC;YACnD,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;gBACrB,6CAA6C;gBAC7C,yDAAyD;gBACzD,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAChC,CAAC;YACD,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,IAAI,kBAAkB,CAAC;YAC1D,MAAM,cAAc,GAAG,aAAa,CAAC,KAAK,CAAC,UAAU,EAAE;gBACrD,KAAK,EAAE,SAAS;aACjB,CAAC,CAAC;YACH,KAAK,CAAC,UAAU,GAAG,cAAc,CAAC;YAClC,kFAAkF;YAClF,wEAAwE;YACxE,sCAAsC;YACtC,6CAA6C;YAC7C,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,kBAAkB,CAAC,cAAc,CAAC,CAAC,CAAC;YAC7D,kCAAkC;YAClC,kFAAkF;YAClF,IAAI,CAAC,GAAG,CAAC,cAAc,GAAG,MAAM,CAAC;YACjC,6CAA6C;YAC7C,OAAO,CAAC,GAAG,CAAC,cAAc,GAAG,MAAM,CAAC;YACpC,sCAAsC;YACtC,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,MAAM,CAAC;YAC7D,6DAA6D;YAC7D,iFAAiF;YACjF,8EAA8E;YAC9E,mCAAmC;YACnC,kBAAkB;QACpB,CAAC;QACD,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,gCAAgC;YAChC,IAAI,SAAS,GAAG,aAAa,CAAC,aAAa,EAAE;gBAC3C,KAAK,EAAE,CAAE,gBAAgB,EAAE,CAAE;aAC9B,CAAC,CAAC;YACH,wDAAwD;YACxD,qEAAqE;YACrE,6DAA6D;YAC7D,kNAAkN;YAClN,SAAS,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC;YAC1C,uDAAuD;YACvD,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,CAAC;YACrC,IAAI,CAAC,cAAc,CAAC,YAAY,SAAS,EAAE,CAAC,CAAC;QAC/C,CAAC;QAED,IAAI,KAAK,CAAC,YAAY,KAAK,SAAS,EAAE,CAAC;YACrC,IAAI,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,KAAK,SAAS,EAAE,CAAC;gBAClD,6DAA6D;gBAC7D,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC;gBAC9C,KAAK,CAAC,kDAAkD,EAAE,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;YACtF,CAAC;QACH,CAAC;QACD,IAAI,KAAK,CAAC,YAAY,EAAE,CAAC;YACvB,MAAM,MAAM,GAAG,aAAa,CAAC,wBAAwB,EAAE;gBACrD,KAAK,EAAE;oBACL,KAAK,CAAC,IAAI;oBACV,gBAAgB,EAAE;iBACnB;aACF,CAAC,CAAC;YACH,KAAK,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAAC;YACnC,MAAM,SAAS,CAAC,QAAQ,MAAM,EAAE,CAAC,CAAC;QACpC,CAAC;QAED,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YACvB,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAE,CAAC;YAChG,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;gBAC7B,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,qBAAqB,MAAM,EAAE,CAAC,CAAC;YAC1D,CAAC;QACH,CAAC;QAED,IAAI,gBAAgB,GAAG,KAAK,CAAC;QAC7B,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YAClB,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;YACjC,gBAAgB,GAAG,IAAI,CAAC;QAC1B,CAAC;QACD,IAAI,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC;YACzB,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,CAAC;YACrC,gBAAgB,GAAG,IAAI,CAAC;QAC1B,CAAC;QACD,IAAI,gBAAgB,EAAE,CAAC;YACrB,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;YACjC,KAAK,CAAC,qCAAqC,CAAC,CAAC;QAC/C,CAAC;aAAM,IAAI,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC;YAClC,sIAAsI;YACtI,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;YACjC,KAAK,CAAC,uDAAuD,EAAE,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QACzF,CAAC;QAED,KAAK,CAAC,wBAAwB,EAAE,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QACxD,KAAK,CAAC,sBAAsB,EAAE,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QACrD,KAAK,CAAC,4BAA4B,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QACjD,KAAK,CAAC,wBAAwB,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;IAC3C,CAAC;IAES,KAAK,CAAC,KAAK,CAAC,GAAgC;QACpD,yDAAyD;QACzD,mDAAmD;QACnD,OAAO,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC1B,CAAC;IAES,KAAK,CAAC,OAAO,CAAC,CAAoB;QAC1C,8EAA8E;QAC9E,OAAO,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAC1B,CAAC;IAES,KAAK,CAAC,cAAc;QAC5B,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,IAAI,EAAE,CAAC;QAC1C,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,IAAI,EAAE,CAAC;QACxC,IAAI,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,OAAmB,IAAI,EAAE,CAAC;QACxD,IAAI,OAAO,WAAW,KAAK,QAAQ,EAAE,CAAC;YACpC,WAAW,GAAG,CAAE,WAAW,CAAE,CAAC;QAChC,CAAC;QACD,IAAI,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,MAAkB,IAAI,EAAE,CAAC;QACtD,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;YACnC,UAAU,GAAG,CAAE,UAAU,CAAE,CAAC;QAC9B,CAAC;QACD,OAAO;YACL,GAAG,QAAQ;YACX,GAAG,OAAO;YACV,GAAG,WAAW;YACd,GAAG,UAAU;SACd,CAAC;IACJ,CAAC;IAES,kBAAkB,CAAC,UAAkB;QAC7C,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,OAAO,YAAY,aAAa,CAAC,UAAU,CAAC,CAAC,IAAI,EAAE,CAAC;QACtD,CAAC;QACD,OAAO,aAAa,UAAU,EAAE,CAAC;IACnC,CAAC;IAES,cAAc,CAAC,OAAe;QACtC,IAAI,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;YAC1B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC7C,IAAI,CAAC,GAAG,CAAC,YAAY,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,IAAI,OAAO,EAAE,CAAC;YAChE,CAAC;QACH,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,GAAG,CAAC,YAAY,GAAG,OAAO,CAAC;QAClC,CAAC;IACH,CAAC;IAES,KAAK,CAAC,QAAQ,CAAC,UAAkB,EAAE,QAAkB,EAAE,UAA2B,EAAE;QAC5F,MAAM,GAAG,GAAG;YACV,GAAG,IAAI,CAAC,GAAG;YACX,GAAG,OAAO,CAAC,GAAG;SACf,CAAC;QACF,MAAM,YAAY,GAAG;YACnB,GAAG,IAAI,CAAC,cAAc;YACtB,GAAG,OAAO,CAAC,QAAQ,IAAI,EAAE;SAC1B,CAAC;QACF,MAAM,YAAY,GAAG,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,iBAAiB,GAAG,CAAC,YAAY,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;QACnF,MAAM,kBAAkB,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,GAAG,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;QAC1F,MAAM,cAAc,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC7D,MAAM,WAAW,GAAG,GAAG,YAAY,GAAG,OAAO,CAAC,QAAQ,GAAG,kBAAkB,GAAG,UAAU,IAAI,cAAc,EAAE,CAAC;QAC7G,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;YACnB,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC;YAC1C,OAAO;QACT,CAAC;QAED,OAAO,GAAG;YACR,KAAK,EAAE,SAAS;YAChB,GAAG;YACH,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;YACpB,GAAG,OAAO;YACV,QAAQ,EAAE,YAAY;SACvB,CAAC;QACF,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;QACjD,KAAK,CAAC,8BAA8B,EAClC,IAAI,CAAC,GAAG,EACR,WAAW,CAAC,CAAC;QACf,QAAQ,CAAC,IAAI,CAAC,CAAC;QAEf,OAAO,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC3C,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE;gBACvB,KAAK,CAAC,2BAA2B,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;gBACnD,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBACtB,IAAI,IAAI,KAAK,CAAC,EAAE,CAAC;oBACf,MAAM,GAAG,GAAG,IAAI,SAAS,CAAC,UAAU,GAAG,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,kBAAkB,GAAG,IAAI,EAAE,IAAI,CAAC,CAAC;oBACnG,MAAM,CAAC,GAAG,CAAC,CAAC;gBACd,CAAC;qBAAM,CAAC;oBACN,OAAO,EAAE,CAAC;gBACZ,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC"}

package/dist/esm/commands/cov.d.ts

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

package/dist/esm/commands/cov.js

@@ -0,0 +1,91 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { Flags } from '@oclif/core';
+import Test from './test.js';
+import { importResolve } from '@eggjs/utils';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+export default class Cov extends Test {
+    static description = 'Run the test with coverage';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> test/index.test.ts',
+    ];
+    static flags = {
+        ...Test.flags,
+        // will use on egg-mock https://github.com/eggjs/egg-mock/blob/84a64bd19d0569ec94664c898fb1b28367b95d60/index.js#L7
+        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/',
+            // https://github.com/JaKXz/test-exclude/blob/620a7be412d4fc2070d50f0f63e3228314066fc9/index.js#L73
+            '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';
+        }
+        // add c8 args
+        // https://github.com/eggjs/egg/issues/3930
+        const c8Args = [
+            // '--show-process-tree',
+            ...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 = [];
+        // $ c8 node mocha
+        await super.forkNode(c8File, [
+            ...c8Args,
+            process.execPath,
+            ...execArgv,
+            modulePath,
+            ...forkArgs,
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/commands/dev.d.ts

@@ -0,0 +1,21 @@
+import { BaseCommand } from '../baseCommand.js';
+export default class Dev<T extends typeof Dev> extends BaseCommand<T> {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        port: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        workers: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        framework: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        sticky: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    protected formatEggStartOptions(): Promise<{
+        baseDir: string;
+        workers: number;
+        port: number;
+        framework: string;
+        typescript: boolean;
+        tscompiler: string | undefined;
+        sticky: boolean;
+    }>;
+}

package/dist/esm/commands/dev.js

@@ -0,0 +1,92 @@
+import { debuglog } from 'node:util';
+import { Flags } from '@oclif/core';
+import { getConfig, getFrameworkPath } from '@eggjs/utils';
+import { detect } from 'detect-port';
+import { getSourceFilename } from '../utils.js';
+import { BaseCommand } from '../baseCommand.js';
+const debug = debuglog('@eggjs/bin/commands/dev');
+export default class Dev 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 imports = this.formatImportModule(r).split(' ');
+            execArgv.push(...imports);
+        }
+        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 {
+                const configuration = await getConfig({
+                    framework: flags.framework,
+                    baseDir: flags.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, 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,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,23 @@
+import { BaseCommand } from '../baseCommand.js';
+export default class Test<T extends typeof Test> extends BaseCommand<T> {
+    static args: {
+        file: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        bail: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        timeout: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        'no-timeout': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        grep: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        changed: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        mochawesome: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        parallel: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        jobs: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        'auto-agent': import("@oclif/core/interfaces").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[]>;
+}