@eggjs/scripts 3.1.0

package/dist/esm/baseCommand.js

@@ -0,0 +1,55 @@
+import { debuglog } from 'node:util';
+import { Command } from '@oclif/core';
+import { readJSON } from 'utility';
+import path from 'node:path';
+const debug = debuglog('@eggjs/scripts/baseCommand');
+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.',
+    // })(),
+    };
+    flags;
+    args;
+    env = { ...process.env };
+    pkg;
+    isESM;
+    pkgEgg;
+    globalExecArgv = [];
+    async init() {
+        await super.init();
+        debug('[init] raw args: %o, NODE_ENV: %o', this.argv, this.env.NODE_ENV);
+        const { args, flags } = await this.parse({
+            flags: this.ctor.flags,
+            baseFlags: super.ctor.baseFlags,
+            enableJsonFlag: this.ctor.enableJsonFlag,
+            args: this.ctor.args,
+            strict: this.ctor.strict,
+        });
+        this.flags = flags;
+        this.args = args;
+    }
+    async initBaseInfo(baseDir) {
+        const pkg = await readJSON(path.join(baseDir, 'package.json'));
+        this.pkg = pkg;
+        this.pkgEgg = pkg.egg ?? {};
+        this.isESM = pkg.type === 'module';
+        debug('[initBaseInfo] baseDir: %o, pkgEgg: %o, isESM: %o', baseDir, this.pkgEgg, this.isESM);
+    }
+    async catch(err) {
+        // 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(_);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/dist/esm/commands/start.js

@@ -0,0 +1,344 @@
+import { debuglog, promisify } from 'node:util';
+import path from 'node:path';
+import { scheduler } from 'node:timers/promises';
+import { spawn, execFile as _execFile } from 'node:child_process';
+import { mkdir, rename, stat, open } from 'node:fs/promises';
+import { homedir } from 'node-homedir';
+import { Args, Flags } from '@oclif/core';
+import { getFrameworkPath, importResolve } from '@eggjs/utils';
+import { readJSON, exists, getDateStringParts } from 'utility';
+import { BaseCommand } from '../baseCommand.js';
+import { getSourceDirname } from '../helper.js';
+const debug = debuglog('@eggjs/scripts/commands/start');
+const execFile = promisify(_execFile);
+export default class Start extends BaseCommand {
+    static description = 'Start server at prod mode';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static args = {
+        baseDir: Args.string({
+            description: 'directory of application',
+            required: false,
+        }),
+    };
+    static flags = {
+        title: Flags.string({
+            description: 'process title description, use for kill grep, default to `egg-server-${APP_NAME}`',
+        }),
+        framework: Flags.string({
+            description: 'specify framework that can be absolute path or npm package',
+        }),
+        port: Flags.integer({
+            description: 'listening port, default to `process.env.PORT`',
+            char: 'p',
+        }),
+        workers: Flags.integer({
+            char: 'c',
+            aliases: ['cluster'],
+            description: 'numbers of app workers, default to `process.env.EGG_WORKERS` or `os.cpus().length`',
+        }),
+        env: Flags.string({
+            description: 'server env, default to `process.env.EGG_SERVER_ENV`',
+            default: process.env.EGG_SERVER_ENV,
+        }),
+        daemon: Flags.boolean({
+            description: 'whether run at background daemon mode',
+        }),
+        stdout: Flags.string({
+            description: 'customize stdout file',
+        }),
+        stderr: Flags.string({
+            description: 'customize stderr file',
+        }),
+        timeout: Flags.integer({
+            description: 'the maximum timeout(ms) when app starts',
+            default: 300 * 1000,
+        }),
+        'ignore-stderr': Flags.boolean({
+            description: 'whether ignore stderr when app starts',
+        }),
+        node: Flags.string({
+            description: 'customize node command path',
+            default: 'node',
+        }),
+        require: Flags.string({
+            summary: 'require the given module',
+            char: 'r',
+            multiple: true,
+        }),
+        sourcemap: Flags.boolean({
+            summary: 'whether enable sourcemap support, will load `source-map-support` etc',
+            aliases: ['ts', 'typescript'],
+        }),
+    };
+    isReady = false;
+    #child;
+    async getFrameworkPath(options) {
+        return getFrameworkPath(options);
+    }
+    async getFrameworkName(frameworkPath) {
+        const pkgPath = path.join(frameworkPath, 'package.json');
+        let name = 'egg';
+        try {
+            const pkg = await readJSON(pkgPath);
+            if (pkg.name) {
+                name = pkg.name;
+            }
+        }
+        catch {
+            // ignore
+        }
+        return name;
+    }
+    async getServerBin() {
+        const serverBinName = this.isESM ? 'start-cluster.mjs' : 'start-cluster.cjs';
+        // for src paths, `./src/commands/start.js`
+        let serverBin = path.join(getSourceDirname(), '../scripts', serverBinName);
+        if (!(await exists(serverBin))) {
+            // for dist paths, `./dist/esm/commands/start.js`
+            serverBin = path.join(getSourceDirname(), '../../scripts', serverBinName);
+        }
+        return serverBin;
+    }
+    async run() {
+        const { args, flags } = this;
+        // context.execArgvObj = context.execArgvObj || {};
+        // const { argv, env, cwd, execArgvObj } = context;
+        const HOME = homedir();
+        const logDir = path.join(HOME, 'logs');
+        // eggctl start
+        // eggctl start ./server
+        // eggctl start /opt/app
+        const cwd = process.cwd();
+        let baseDir = args.baseDir || cwd;
+        if (!path.isAbsolute(baseDir)) {
+            baseDir = path.join(cwd, baseDir);
+        }
+        await this.initBaseInfo(baseDir);
+        flags.framework = await this.getFrameworkPath({
+            framework: flags.framework,
+            baseDir,
+        });
+        const frameworkName = await this.getFrameworkName(flags.framework);
+        flags.title = flags.title || `egg-server-${this.pkg.name}`;
+        flags.stdout = flags.stdout || path.join(logDir, 'master-stdout.log');
+        flags.stderr = flags.stderr || path.join(logDir, 'master-stderr.log');
+        if (flags.workers === undefined && process.env.EGG_WORKERS) {
+            flags.workers = Number(process.env.EGG_WORKERS);
+        }
+        // normalize env
+        this.env.HOME = HOME;
+        this.env.NODE_ENV = 'production';
+        // it makes env big but more robust
+        this.env.PATH = this.env.Path = [
+            // for nodeinstall
+            path.join(baseDir, 'node_modules/.bin'),
+            // support `.node/bin`, due to npm5 will remove `node_modules/.bin`
+            path.join(baseDir, '.node/bin'),
+            // adjust env for win
+            this.env.PATH || this.env.Path,
+        ].filter(x => !!x).join(path.delimiter);
+        // for alinode
+        this.env.ENABLE_NODE_LOG = 'YES';
+        this.env.NODE_LOG_DIR = this.env.NODE_LOG_DIR || path.join(logDir, 'alinode');
+        await mkdir(this.env.NODE_LOG_DIR, { recursive: true });
+        // cli argv -> process.env.EGG_SERVER_ENV -> `undefined` then egg will use `prod`
+        if (flags.env) {
+            // if undefined, should not pass key due to `spawn`, https://github.com/nodejs/node/blob/master/lib/child_process.js#L470
+            this.env.EGG_SERVER_ENV = flags.env;
+        }
+        // additional execArgv
+        const execArgv = [
+            '--no-deprecation',
+            '--trace-warnings',
+        ];
+        if (this.pkgEgg.revert) {
+            const reverts = Array.isArray(this.pkgEgg.revert) ? this.pkgEgg.revert : [this.pkgEgg.revert];
+            for (const revert of reverts) {
+                execArgv.push(`--security-revert=${revert}`);
+            }
+        }
+        // pkg.eggScriptsConfig.require
+        const scriptsConfig = this.pkg.eggScriptsConfig;
+        if (scriptsConfig?.require) {
+            scriptsConfig.require = Array.isArray(scriptsConfig.require) ? scriptsConfig.require : [scriptsConfig.require];
+            flags.require = [...scriptsConfig.require, ...(flags.require ?? [])];
+        }
+        // read argv from eggScriptsConfig in package.json
+        if (scriptsConfig) {
+            for (const key in scriptsConfig) {
+                const v = scriptsConfig[key];
+                if (key.startsWith('node-options--')) {
+                    const newKey = key.replace('node-options--', '');
+                    if (v === true) {
+                        // "node-options--allow-wasi": true
+                        // => --allow-wasi
+                        execArgv.push(`--${newKey}`);
+                    }
+                    else {
+                        // "node-options--max-http-header-size": "20000"
+                        // => --max-http-header-size=20000
+                        execArgv.push(`--${newKey}=${v}`);
+                    }
+                    continue;
+                }
+                const existsValue = Reflect.get(flags, key);
+                if (existsValue === undefined) {
+                    // only set if key is not pass from command line
+                    Reflect.set(flags, key, v);
+                }
+            }
+        }
+        // read `egg.typescript` from package.json
+        if (this.pkgEgg.typescript && flags.sourcemap === undefined) {
+            flags.sourcemap = true;
+        }
+        if (flags.sourcemap) {
+            const sourceMapSupport = importResolve('source-map-support/register.js', {
+                paths: [getSourceDirname()],
+            });
+            if (this.isESM) {
+                execArgv.push('--import', sourceMapSupport);
+            }
+            else {
+                execArgv.push('--require', sourceMapSupport);
+            }
+        }
+        if (flags.port === undefined && process.env.PORT) {
+            flags.port = parseInt(process.env.PORT);
+        }
+        debug('flags: %o, framework: %o, baseDir: %o, execArgv: %o', flags, frameworkName, baseDir, execArgv);
+        const command = flags.node;
+        const options = {
+            env: this.env,
+            stdio: 'inherit',
+            detached: false,
+            cwd: baseDir,
+        };
+        this.log('Starting %s application at %s', frameworkName, baseDir);
+        // remove unused properties from stringify, alias had been remove by `removeAlias`
+        const ignoreKeys = ['env', 'daemon', 'stdout', 'stderr', 'timeout', 'ignore-stderr', 'node'];
+        const clusterOptions = stringify({
+            ...flags,
+            baseDir,
+        }, ignoreKeys);
+        // Note: `spawn` is not like `fork`, had to pass `execArgv` yourself
+        const serverBin = await this.getServerBin();
+        const eggArgs = [...execArgv, serverBin, clusterOptions, `--title=${flags.title}`];
+        const spawnScript = `${command} ${eggArgs.map(a => `'${a}'`).join(' ')}`;
+        this.log('Spawn %o', spawnScript);
+        // whether run in the background.
+        if (flags.daemon) {
+            this.log(`Save log file to ${logDir}`);
+            const [stdout, stderr] = await Promise.all([
+                getRotateLog(flags.stdout),
+                getRotateLog(flags.stderr),
+            ]);
+            options.stdio = ['ignore', stdout, stderr, 'ipc'];
+            options.detached = true;
+            const child = this.#child = spawn(command, eggArgs, options);
+            this.isReady = false;
+            child.on('message', (msg) => {
+                // https://github.com/eggjs/cluster/blob/master/src/master.ts#L119
+                if (msg && msg.action === 'egg-ready') {
+                    this.isReady = true;
+                    this.log('%s started on %s', frameworkName, msg.data.address);
+                    child.unref();
+                    child.disconnect();
+                }
+            });
+            // check start status
+            await this.checkStatus();
+        }
+        else {
+            options.stdio = ['inherit', 'inherit', 'inherit', 'ipc'];
+            const child = this.#child = spawn(command, eggArgs, options);
+            child.once('exit', code => {
+                if (!code)
+                    return;
+                // command should exit after child process exit
+                this.exit(code);
+            });
+            // attach master signal to child
+            let signal;
+            const signals = ['SIGINT', 'SIGQUIT', 'SIGTERM'];
+            signals.forEach(event => {
+                process.once(event, () => {
+                    debug('Kill child %s with %s', child.pid, signal);
+                    child.kill(event);
+                });
+            });
+        }
+    }
+    async checkStatus() {
+        let count = 0;
+        let hasError = false;
+        let isSuccess = true;
+        const timeout = this.flags.timeout / 1000;
+        const stderrFile = this.flags.stderr;
+        while (!this.isReady) {
+            try {
+                const stats = await stat(stderrFile);
+                if (stats && stats.size > 0) {
+                    hasError = true;
+                    break;
+                }
+            }
+            catch (_) {
+                // nothing
+            }
+            if (count >= timeout) {
+                this.logToStderr('Start failed, %ds timeout', timeout);
+                isSuccess = false;
+                break;
+            }
+            await scheduler.wait(1000);
+            this.log('Wait Start: %d...', ++count);
+        }
+        if (hasError) {
+            try {
+                const args = ['-n', '100', stderrFile];
+                this.logToStderr('tail %s', args.join(' '));
+                const { stdout: headStdout } = await execFile('head', args);
+                const { stdout: tailStdout } = await execFile('tail', args);
+                this.logToStderr('Got error when startup: ');
+                this.logToStderr(headStdout);
+                this.logToStderr('...');
+                this.logToStderr(tailStdout);
+            }
+            catch (err) {
+                this.logToStderr('ignore tail error: %s', err);
+            }
+            isSuccess = this.flags['ignore-stderr'];
+            this.logToStderr('Start got error, see %o', stderrFile);
+            this.logToStderr('Or use `--ignore-stderr` to ignore stderr at startup.');
+        }
+        if (!isSuccess) {
+            this.#child.kill('SIGTERM');
+            await scheduler.wait(1000);
+            this.exit(1);
+        }
+    }
+}
+function stringify(obj, ignore) {
+    const result = {};
+    Object.keys(obj).forEach(key => {
+        if (!ignore.includes(key)) {
+            result[key] = obj[key];
+        }
+    });
+    return JSON.stringify(result);
+}
+async function getRotateLog(logFile) {
+    await mkdir(path.dirname(logFile), { recursive: true });
+    if (await exists(logFile)) {
+        // format style: .20150602.193100
+        const [YYYY, MM, DD, HH, mm, ss] = getDateStringParts();
+        const timestamp = `.${YYYY}${MM}${DD}.${HH}${mm}${ss}`;
+        // Note: rename last log to next start time, not when last log file created
+        await rename(logFile, logFile + timestamp);
+    }
+    return (await open(logFile, 'a')).fd;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"start.js","sourceRoot":"","sources":["../../../src/commands/start.ts"],"names":[],"mappings":"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"}

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

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

package/dist/esm/commands/stop.js

@@ -0,0 +1,87 @@
+import { debuglog, format } from 'node:util';
+import { scheduler } from 'node:timers/promises';
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../baseCommand.js';
+import { isWindows, findNodeProcess, kill } from '../helper.js';
+const debug = debuglog('@eggjs/scripts/commands/stop');
+const osRelated = {
+    titleTemplate: isWindows ? '\\"title\\":\\"%s\\"' : '"title":"%s"',
+    // node_modules/@eggjs/cluster/dist/commonjs/app_worker.js
+    // node_modules/@eggjs/cluster/dist/esm/app_worker.js
+    appWorkerPath: /@eggjs[\/\\]cluster[\/\\]dist[\/\\](commonjs|esm)[\/\\]app_worker\.js/i,
+    // node_modules/@eggjs/cluster/dist/commonjs/agent_worker.js
+    // node_modules/@eggjs/cluster/dist/esm/agent_worker.js
+    agentWorkerPath: /@eggjs[\/\\]cluster[\/\\]dist[\/\\](commonjs|esm)[\/\\]agent_worker\.js/i,
+};
+export default class Stop extends BaseCommand {
+    static description = 'Stop server';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static args = {
+        baseDir: Args.string({
+            description: 'directory of application',
+            required: false,
+        }),
+    };
+    static flags = {
+        title: Flags.string({
+            description: 'process title description, use for kill grep',
+        }),
+        timeout: Flags.integer({
+            description: 'the maximum timeout(ms) when app stop',
+            default: 5000,
+        }),
+    };
+    async run() {
+        const { flags } = this;
+        this.log(`stopping egg application${flags.title ? ` with --title=${flags.title}` : ''}`);
+        // node ~/eggjs/scripts/scripts/start-cluster.cjs {"title":"egg-server","workers":4,"port":7001,"baseDir":"~/eggjs/test/showcase","framework":"~/eggjs/test/showcase/node_modules/egg"}
+        let processList = await this.findNodeProcesses(item => {
+            const cmd = item.cmd;
+            const matched = flags.title ?
+                cmd.includes('start-cluster') && cmd.includes(format(osRelated.titleTemplate, flags.title)) :
+                cmd.includes('start-cluster');
+            if (matched) {
+                debug('find master process: %o', item);
+            }
+            return matched;
+        });
+        let pids = processList.map(x => x.pid);
+        if (pids.length) {
+            this.log('got master pid %j', pids);
+            this.killProcesses(pids);
+            // wait for 5s to confirm whether any worker process did not kill by master
+            await scheduler.wait(flags.timeout);
+        }
+        else {
+            this.logToStderr('can\'t detect any running egg process');
+        }
+        // node --debug-port=5856 /Users/tz/Workspaces/eggjs/test/showcase/node_modules/_egg-cluster@1.8.0@egg-cluster/lib/agent_worker.js {"framework":"/Users/tz/Workspaces/eggjs/test/showcase/node_modules/egg","baseDir":"/Users/tz/Workspaces/eggjs/test/showcase","port":7001,"workers":2,"plugins":null,"https":false,"key":"","cert":"","title":"egg-server","clusterPort":52406}
+        // node /Users/tz/Workspaces/eggjs/test/showcase/node_modules/_egg-cluster@1.8.0@egg-cluster/lib/app_worker.js {"framework":"/Users/tz/Workspaces/eggjs/test/showcase/node_modules/egg","baseDir":"/Users/tz/Workspaces/eggjs/test/showcase","port":7001,"workers":2,"plugins":null,"https":false,"key":"","cert":"","title":"egg-server","clusterPort":52406}
+        // ~/bin/node --no-deprecation --trace-warnings ~/eggjs/examples/helloworld/node_modules/@eggjs/cluster/dist/commonjs/agent_worker.js {"baseDir":"~/eggjs/examples/helloworld","startMode":"process","framework":"~/eggjs/examples/helloworld/node_modules/egg","title":"egg-server-helloworld","workers":10,"clusterPort":58977}
+        processList = await this.findNodeProcesses(item => {
+            const cmd = item.cmd;
+            const matched = flags.title ?
+                (osRelated.appWorkerPath.test(cmd) || osRelated.agentWorkerPath.test(cmd)) && cmd.includes(format(osRelated.titleTemplate, flags.title)) :
+                (osRelated.appWorkerPath.test(cmd) || osRelated.agentWorkerPath.test(cmd));
+            if (matched) {
+                debug('find app/agent worker process: %o', item);
+            }
+            return matched;
+        });
+        pids = processList.map(x => x.pid);
+        if (pids.length) {
+            this.log('got worker/agent pids %j that is not killed by master', pids);
+            this.killProcesses(pids);
+        }
+        this.log('stopped');
+    }
+    async findNodeProcesses(filter) {
+        return findNodeProcess(filter);
+    }
+    killProcesses(pids, signal = 'SIGTERM') {
+        kill(pids, signal);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/helper.d.ts

@@ -0,0 +1,10 @@
+export declare const isWindows: boolean;
+export interface NodeProcess {
+    pid: number;
+    cmd: string;
+}
+export type FilterFunction = (item: NodeProcess) => boolean;
+export declare function findNodeProcess(filterFn?: FilterFunction): Promise<NodeProcess[]>;
+export declare function kill(pids: number[], signal?: string | number): void;
+export declare function getSourceDirname(): string;
+export declare function getSourceFilename(filename: string): string;

package/dist/esm/helper.js

@@ -0,0 +1,51 @@
+import { runScript } from 'runscript';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const isWindows = process.platform === 'win32';
+const REGEX = isWindows ? /^(.*)\s+(\d+)\s*$/ : /^\s*(\d+)\s+(.*)/;
+export async function findNodeProcess(filterFn) {
+    const command = isWindows ?
+        'wmic Path win32_process Where "Name = \'node.exe\'" Get CommandLine,ProcessId' :
+        // command, cmd are alias of args, not POSIX standard, so we use args
+        'ps -wweo "pid,args"';
+    const stdio = await runScript(command, { stdio: 'pipe' });
+    const processList = stdio.stdout.toString().split('\n')
+        .reduce((arr, line) => {
+        if (!!line && !line.includes('/bin/sh') && line.includes('node')) {
+            const m = line.match(REGEX);
+            if (m) {
+                const item = isWindows ? { pid: parseInt(m[2]), cmd: m[1] } : { pid: parseInt(m[1]), cmd: m[2] };
+                if (filterFn?.(item)) {
+                    arr.push(item);
+                }
+            }
+        }
+        return arr;
+    }, []);
+    return processList;
+}
+export function kill(pids, signal) {
+    pids.forEach(pid => {
+        try {
+            process.kill(pid, signal);
+        }
+        catch (err) {
+            if (err.code !== 'ESRCH') {
+                throw err;
+            }
+        }
+    });
+}
+export function getSourceDirname() {
+    if (typeof __dirname === 'string') {
+        return __dirname;
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    const __filename = fileURLToPath(import.meta.url);
+    return path.dirname(__filename);
+}
+export function getSourceFilename(filename) {
+    return path.join(getSourceDirname(), filename);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/index.d.ts

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