uni-run 0.0.2 → 0.0.4

package/dist/arg-helper.d.ts

@@ -0,0 +1,62 @@
+import NoArg from 'noarg';
+import type { app } from './arg';
+import { ExecuteOptions } from './execution';
+export declare const executionConfig: {
+    readonly flags: {
+        readonly cwd: import("noarg/dist/schema/TypeString.cjs").TypeString<{
+            required: true;
+            default: string;
+            description: "The current working directory";
+        }>;
+        readonly clear: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            description: "Clear the console before running the script";
+            required: true;
+            default: true;
+            aliases: [string];
+        }>;
+        readonly reload: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            description: "Reload the page when pressing \"Ctrl+R\" or \"Meta+R\"";
+            required: true;
+            default: true;
+            aliases: [string];
+        }>;
+        readonly watch: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            description: "Watch for changes";
+            required: true;
+            default: true;
+            aliases: [string];
+        }>;
+        readonly watchDelay: import("noarg/dist/schema/TypeNumber.cjs").TypeNumber<{
+            description: "The delay to wait for the watcher to trigger";
+            required: true;
+            default: 100;
+            aliases: [string];
+        }>;
+        readonly ext: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            description: "Looks for changes only of the given extensions";
+            required: true;
+            default: never[];
+            schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+            aliases: [string];
+        }>;
+        readonly ignore: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            required: true;
+            default: never[];
+            schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+            description: "Ignore the given targets";
+        }>;
+        readonly env: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            required: true;
+            default: never[];
+            schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+            description: "Environment variables";
+        }>;
+    };
+    readonly listArgument: {
+        readonly name: "args";
+        readonly description: "The arguments to pass to the script";
+        readonly type: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+    };
+    readonly trailingArguments: "--";
+};
+export declare function mapFlagsToOptions(flags: NoArg.InferFlags<typeof app>, watchExtensions?: string[]): ExecuteOptions;

package/dist/arg-helper.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executionConfig = void 0;
+exports.mapFlagsToOptions = mapFlagsToOptions;
+const noarg_1 = require("noarg");
+exports.executionConfig = noarg_1.default.defineConfig({
+    flags: {
+        cwd: noarg_1.default.string()
+            .default(process.cwd())
+            .description('The current working directory'),
+        clear: noarg_1.default.boolean()
+            .default(true)
+            .description('Clear the console before running the script')
+            .aliases('c'),
+        reload: noarg_1.default.boolean()
+            .default(true)
+            .description('Reload the page when pressing "Ctrl+R" or "Meta+R"')
+            .aliases('r'),
+        watch: noarg_1.default.boolean()
+            .default(true)
+            .description('Watch for changes')
+            .aliases('w'),
+        watchDelay: noarg_1.default.number()
+            .default(100)
+            .description('The delay to wait for the watcher to trigger')
+            .aliases('wd'),
+        ext: noarg_1.default.array(noarg_1.default.string())
+            .default([])
+            .description('Looks for changes only of the given extensions')
+            .aliases('e'),
+        ignore: noarg_1.default.array(noarg_1.default.string())
+            .default([])
+            .description('Ignore the given targets'),
+        env: noarg_1.default.array(noarg_1.default.string())
+            .default([])
+            .description('Environment variables'),
+    },
+    listArgument: {
+        name: 'args',
+        description: 'The arguments to pass to the script',
+        type: noarg_1.default.string(),
+    },
+    trailingArguments: '--',
+});
+function mapFlagsToOptions(flags, watchExtensions) {
+    return {
+        cwd: flags.cwd,
+        clearOnReload: flags.clear,
+        readlineReload: flags.reload,
+        env: flags.env.reduce((acc, env) => {
+            const [key, value] = env.split('=');
+            acc[key] = value;
+            return acc;
+        }, {}),
+        watch: flags.watch,
+        watchDelay: flags.watchDelay,
+        watchExtensions: flags.ext.length ? flags.ext : watchExtensions !== null && watchExtensions !== void 0 ? watchExtensions : [],
+        watchIgnore: flags.ignore,
+    };
+}

package/dist/arg.d.ts

@@ -9,10 +9,11 @@ export declare const app: NoArg<"uni-run", {
 }, {
     readonly optionalArguments: [];
     readonly globalFlags: {};
+    readonly description: "A universal runner for scripts";
     readonly arguments: [{
         readonly name: "script";
-        readonly description: "Run a script";
         readonly type: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+        readonly description: "Run a script";
     }];
     readonly listArgument: {
         readonly name: "args";

package/dist/arg.js

@@ -2,52 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.exec = exports.app = void 0;
 const noarg_1 = require("noarg");
-const executionConfig = noarg_1.default.defineConfig({
-    flags: {
-        cwd: noarg_1.default.string()
-            .default(process.cwd())
-            .description('The current working directory'),
-        clear: noarg_1.default.boolean()
-            .default(true)
-            .description('Clear the console before running the script')
-            .aliases('c'),
-        reload: noarg_1.default.boolean()
-            .default(true)
-            .description('Reload the page when pressing "Ctrl+R" or "Meta+R"')
-            .aliases('r'),
-        watch: noarg_1.default.boolean()
-            .default(true)
-            .description('Watch for changes')
-            .aliases('w'),
-        watchDelay: noarg_1.default.number()
-            .default(100)
-            .description('The delay to wait for the watcher to trigger')
-            .aliases('wd'),
-        ext: noarg_1.default.array(noarg_1.default.string())
-            .default([])
-            .description('Looks for changes only of the given extensions')
-            .aliases('e'),
-        ignore: noarg_1.default.array(noarg_1.default.string())
-            .default([])
-            .description('Ignore the given targets'),
-        env: noarg_1.default.array(noarg_1.default.string())
-            .default([])
-            .description('Environment variables'),
-    },
-    listArgument: {
-        name: 'args',
-        description: 'The arguments to pass to the script',
-        type: noarg_1.default.string(),
-    },
-    trailingArguments: '--',
-});
-exports.app = noarg_1.default.create('uni-run', Object.assign(Object.assign({}, executionConfig), { arguments: [
-        {
-            name: 'script',
-            description: 'Run a script',
-            type: noarg_1.default.string(),
-        },
-    ], system: {
-        splitListByComma: true,
-    } }));
-exports.exec = exports.app.create('exec', Object.assign(Object.assign({}, executionConfig), { description: 'Execute a script with the given binary' }));
+const arg_helper_1 = require("./arg-helper");
+exports.app = noarg_1.default.create('uni-run', Object.assign(Object.assign({}, arg_helper_1.executionConfig), { description: 'A universal runner for scripts', system: { splitListByComma: true }, arguments: [
+        { name: 'script', type: noarg_1.default.string(), description: 'Run a script' },
+    ] }));
+exports.exec = exports.app.create('exec', Object.assign(Object.assign({}, arg_helper_1.executionConfig), { description: 'Execute a script with the given binary' }));

package/dist/builtin-bin/Executor.d.ts

@@ -0,0 +1,19 @@
+type ExecutionBinConfig = {
+    command: string;
+    extensions: string[];
+    watchExtensions?: string[];
+    runArgs?: string[];
+    checkInstallationArgs?: string[];
+    howToInstall?: () => void;
+    installCommands?: string[][];
+};
+export default class Executor {
+    name: string;
+    config: ExecutionBinConfig;
+    constructor(name: string, config: ExecutionBinConfig);
+    getArgs(...args: string[]): string[];
+    isSupported(script: string): boolean;
+    isInstalled(): boolean;
+    renderHowToInstall(): void;
+}
+export {};

package/dist/builtin-bin/Executor.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const confirm_1 = require("@inquirer/confirm");
+const cross_spawn_1 = require("cross-spawn");
+class Executor {
+    constructor(name, config) {
+        var _a;
+        this.name = name;
+        this.config = config;
+        (_a = this.config.watchExtensions) === null || _a === void 0 ? void 0 : _a.push(...this.config.extensions);
+    }
+    getArgs(...args) {
+        var _a;
+        return [this.config.command, ...((_a = this.config.runArgs) !== null && _a !== void 0 ? _a : []), ...args];
+    }
+    isSupported(script) {
+        return this.config.extensions.includes(script.split('.').pop() || '');
+    }
+    isInstalled() {
+        const result = (0, cross_spawn_1.sync)(this.config.command, [...(this.config.checkInstallationArgs || [])], { stdio: 'ignore' });
+        if (result.status === 1)
+            return false;
+        return true;
+    }
+    renderHowToInstall() {
+        var _a;
+        console.error(`${this.name} is not installed.`);
+        if (this.config.howToInstall) {
+            console.log('How to install:');
+            this.config.howToInstall();
+        }
+        if (!((_a = this.config.installCommands) === null || _a === void 0 ? void 0 : _a.length))
+            return;
+        (0, confirm_1.default)({ message: 'Do you want to install it?' }).then((ans) => {
+            var _a;
+            if (!ans)
+                return;
+            (_a = this.config.installCommands) === null || _a === void 0 ? void 0 : _a.forEach(([command, ...args]) => {
+                if (!command)
+                    return;
+                (0, cross_spawn_1.sync)(command, args, { stdio: 'inherit' });
+            });
+        });
+    }
+}
+exports.default = Executor;

package/dist/builtin-bin/index.d.ts

@@ -1,3 +1,3 @@
-import ExecutionBin from './ExecutionBin';
-declare const _default: ExecutionBin[];
+import Executor from './Executor';
+declare const _default: Executor[];
 export default _default;

package/dist/builtin-bin/index.js

@@ -1,53 +1,84 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ExecutionBin_1 = require("./ExecutionBin");
+const Executor_1 = require("./Executor");
 exports.default = [
-    new ExecutionBin_1.default({
-        name: 'Node.js',
+    new Executor_1.default('Node.js', {
         command: 'node',
         extensions: ['js', 'javascript', 'jsx', 'cjs', 'cjsx', 'mjs', 'mjsx'],
-        run(...args) {
-            return [this.command, ...args];
-        },
+        watchExtensions: ['html', 'css', 'json'],
         checkInstallationArgs: ['--version'],
         howToInstall: () => {
             console.log('Please install Node.js from https://nodejs.org/');
         },
     }),
-    new ExecutionBin_1.default({
-        name: 'TypeScript',
+    new Executor_1.default('TypeScript', {
         command: 'ts-node',
         extensions: ['ts', 'tsx', 'cts', 'ctsx', 'mts', 'mtsx'],
-        run(...args) {
-            return [this.command, ...args];
-        },
+        watchExtensions: [
+            'html',
+            'css',
+            'json',
+            'js',
+            'javascript',
+            'jsx',
+            'cjs',
+            'cjsx',
+            'mjs',
+            'mjsx',
+        ],
         checkInstallationArgs: ['--version'],
+        installCommands: [['npm', 'install', '-g', 'ts-node']],
         howToInstall: () => {
             console.log('Please install ts-node from https://www.npmjs.com/package/ts-node');
         },
     }),
-    new ExecutionBin_1.default({
-        name: 'python',
+    new Executor_1.default('Python', {
         command: 'python',
         extensions: ['py'],
-        run(...args) {
-            return [this.command, ...args];
-        },
         checkInstallationArgs: ['--version'],
         howToInstall: () => {
             console.log('Please install Python from https://www.python.org/');
         },
     }),
-    new ExecutionBin_1.default({
-        name: 'java',
+    new Executor_1.default('Java - Oracle', {
         command: 'java',
         extensions: ['java'],
-        run(...args) {
-            return [this.command, ...args];
-        },
         checkInstallationArgs: ['--version'],
         howToInstall: () => {
             console.log('Please install Java from https://www.oracle.com/java/');
         },
     }),
+    new Executor_1.default('Powershell', {
+        command: 'powershell',
+        extensions: ['ps1'],
+        checkInstallationArgs: ['-command', '"Get-Host"'],
+        howToInstall: () => {
+            console.log('Please install Powershell from https://docs.microsoft.com/en-us/powershell/scripting/install/installing-powershell');
+        },
+    }),
+    new Executor_1.default('Cmd - Command Prompt', {
+        command: 'cmd',
+        runArgs: ['/c'],
+        extensions: ['cmd', 'bat'],
+        checkInstallationArgs: ['/c', 'echo', 'ok'],
+        howToInstall: () => {
+            console.log('Please install Command Prompt from Windows');
+        },
+    }),
+    new Executor_1.default('Shell', {
+        command: 'bash',
+        extensions: ['sh'],
+        checkInstallationArgs: ['--version'],
+        howToInstall: () => {
+            console.log('Please install Bash from https://www.gnu.org/software/bash/');
+        },
+    }),
+    new Executor_1.default('Lua', {
+        command: 'lua',
+        extensions: ['lua'],
+        checkInstallationArgs: ['--version'],
+        howToInstall: () => {
+            console.log('Please install Lua from https://www.lua.org/');
+        },
+    }),
 ];

package/dist/execution/index.d.ts

@@ -0,0 +1,22 @@
+export default class Execution {
+    private command;
+    private args;
+    private options;
+    private child;
+    static start([command, ...args]: string[], options: ExecuteOptions): Execution;
+    constructor(command: string, args: string[], options: ExecuteOptions);
+    private setup;
+    private runProcess;
+    private killProcess;
+    private clearBeforeStart;
+}
+export type ExecuteOptions = {
+    cwd: string;
+    clearOnReload: boolean;
+    readlineReload: boolean;
+    watch: boolean;
+    watchDelay: number;
+    watchIgnore: string[];
+    watchExtensions: string[];
+    env: Record<string, string>;
+};

package/dist/execution/index.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cross_spawn_1 = require("cross-spawn");
+const readline = require("readline");
+const watcher_1 = require("./watcher");
+const colors_1 = require("../utils/colors");
+const kill_process_1 = require("./kill-process");
+class Execution {
+    static start([command, ...args], options) {
+        return new Execution(command, args, options);
+    }
+    constructor(command, args, options) {
+        this.command = command;
+        this.args = args;
+        this.options = options;
+        this.child = null;
+        this.setup();
+        this.runProcess();
+    }
+    setup() {
+        var _a, _b;
+        if (this.options.readlineReload) {
+            readline.emitKeypressEvents(process.stdin);
+            (_b = (_a = process.stdin).setRawMode) === null || _b === void 0 ? void 0 : _b.call(_a, true);
+            process.stdin.on('keypress', (_, key) => {
+                if (key.name === 'f5')
+                    return this.runProcess();
+                if ((key.ctrl || key.meta) && key.name === 'r')
+                    return this.runProcess();
+                if (key.ctrl && key.name === 'c') {
+                    this.killProcess();
+                    process.exit(0);
+                }
+            });
+        }
+        if (this.options.watch) {
+            (0, watcher_1.default)(this.options.cwd, {
+                ignore: this.options.watchIgnore,
+                debounceDelay: this.options.watchDelay,
+                extensions: new Set(this.options.watchExtensions),
+            }, () => this.runProcess());
+        }
+    }
+    runProcess() {
+        this.killProcess();
+        this.clearBeforeStart();
+        this.child = (0, cross_spawn_1.spawn)(this.command, this.args, {
+            stdio: 'inherit',
+            cwd: this.options.cwd,
+            env: Object.assign({}, this.options.env),
+        });
+        this.child.on('error', console.error);
+        this.child.on('exit', (code) => {
+            if (code && code > 0) {
+                console.log('');
+                console.log(colors_1.default.red(`Process exited with code: ${colors_1.default.yellow(String(code))}`));
+            }
+            if (this.options.readlineReload) {
+                console.log(colors_1.default.blue.dim(`⟳ Press ${colors_1.default.yellow('F5')} or ${colors_1.default.yellow('^R')} to reload...`));
+            }
+        });
+    }
+    killProcess() {
+        if (!this.child)
+            return;
+        this.child.removeAllListeners();
+        if (!(0, kill_process_1.default)(this.child)) {
+            console.error(colors_1.default.red('Failed to kill the previous process'));
+        }
+        this.child = null;
+    }
+    clearBeforeStart() {
+        if (this.options.clearOnReload) {
+            process.stdout.write('\x1Bc');
+            console.clear();
+        }
+    }
+}
+exports.default = Execution;

package/dist/execution/kill-process.d.ts

@@ -0,0 +1,2 @@
+import { ChildProcess } from 'child_process';
+export default function (child: ChildProcess): boolean;

package/dist/execution/kill-process.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const os = require("os");
+const child_process_1 = require("child_process");
+function default_1(child) {
+    if (!child.pid)
+        return true;
+    child.removeAllListeners();
+    const isWindows = os.platform() === 'win32';
+    try {
+        if (isWindows) {
+            (0, child_process_1.execSync)(`taskkill /pid ${child.pid} /T /F`, { stdio: 'ignore' });
+        }
+        else {
+            process.kill(-child.pid, 'SIGKILL');
+        }
+    }
+    catch (_a) { }
+    try {
+        process.kill(child.pid, 0);
+        return false;
+    }
+    catch (error) {
+        return true;
+    }
+}

package/dist/index.js

@@ -1,44 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const arg = require("./arg");
+const execution_1 = require("./execution");
 const builtin_bin_1 = require("./builtin-bin");
-const execute_1 = require("./execute");
-function mapFlagsToOptions(flags) {
-    return {
-        cwd: flags.cwd,
-        clearOnReload: flags.clear,
-        readlineReload: flags.reload,
-        env: flags.env.reduce((acc, env) => {
-            const [key, value] = env.split('=');
-            acc[key] = value;
-            return acc;
-        }, {}),
-        watch: flags.watch,
-        watchDelay: flags.watchDelay,
-        watchExtensions: flags.ext,
-        watchIgnore: flags.ignore,
-    };
-}
+const arg_helper_1 = require("./arg-helper");
 arg.app.on(([script, listArs, trailingArgs], flags) => {
-    if (script) {
-        const bin = builtin_bin_1.default.find((bin) => bin.isSupported(script));
-        if (!bin) {
-            console.log('Unsupported script:', script);
-            console.log('You may try "ur exec bin script.ext - --flags"');
-            process.exit(1);
-        }
-        if (!bin.isInstalled()) {
-            console.error(`${bin.displayName} is not installed.`);
-            if (bin.howToInstall) {
-                console.log('How to install:');
-                bin.howToInstall();
-            }
-            process.exit(1);
-        }
-        return (0, execute_1.default)(bin.run(script, ...listArs, ...trailingArgs), mapFlagsToOptions(flags));
+    const bin = builtin_bin_1.default.find((bin) => bin.isSupported(script));
+    if (!bin) {
+        console.log('Unsupported script:', script);
+        return console.log('You may try "ur exec bin script.ext - --flags"');
     }
-    arg.app.renderHelp();
+    if (!bin.isInstalled()) {
+        return bin.renderHowToInstall();
+    }
+    execution_1.default.start(bin.getArgs(script, ...listArs, ...trailingArgs), (0, arg_helper_1.mapFlagsToOptions)(flags, bin.config.watchExtensions));
 });
 arg.exec.on(([listArs, trailingArgs], flags) => {
-    (0, execute_1.default)([...listArs, ...trailingArgs], mapFlagsToOptions(flags));
+    execution_1.default.start([...listArs, ...trailingArgs], (0, arg_helper_1.mapFlagsToOptions)(flags));
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "uni-run",
   "description": "Universal Runner for many language",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "commonjs",
   "scripts": {
     "ts": "w ./src/__lab__/index.ts",
@@ -22,6 +22,7 @@
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.6",
+    "@types/node": "^22.5.0",
     "typescript": "^5.5.4"
   },
   "repository": {

package/dist/builtin-bin/ExecutionBin.d.ts

@@ -1,18 +0,0 @@
-export default class ExecutionBin {
-    displayName: string;
-    command: string;
-    run: (...args: string[]) => [command: string, ...args: string[]];
-    extensions: Set<string>;
-    checkInstallationArgs?: string[];
-    howToInstall?: () => void;
-    constructor(config: {
-        name: string;
-        command: string;
-        extensions: string[];
-        run: (...args: string[]) => [command: string, ...args: string[]];
-        checkInstallationArgs?: string[];
-        howToInstall?: () => void;
-    });
-    isSupported(script: string): boolean;
-    isInstalled(): boolean;
-}

package/dist/builtin-bin/ExecutionBin.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const cross_spawn_1 = require("cross-spawn");
-class ExecutionBin {
-    constructor(config) {
-        this.displayName = config.name;
-        this.command = config.command;
-        this.extensions = new Set(config.extensions);
-        this.run = config.run;
-        this.checkInstallationArgs = config.checkInstallationArgs;
-        this.howToInstall = config.howToInstall;
-    }
-    isSupported(script) {
-        return this.extensions.has(script.split('.').pop() || '');
-    }
-    isInstalled() {
-        const result = (0, cross_spawn_1.sync)(this.command, this.checkInstallationArgs ? this.checkInstallationArgs : [], { shell: false, stdio: 'ignore' });
-        if (result.status === 1)
-            return false;
-        return true;
-    }
-}
-exports.default = ExecutionBin;

package/dist/execute.d.ts

@@ -1,11 +0,0 @@
-export type ExecuteOptions = {
-    cwd: string;
-    clearOnReload: boolean;
-    readlineReload: boolean;
-    watch: boolean;
-    watchDelay: number;
-    watchIgnore: string[];
-    watchExtensions: string[];
-    env?: Record<string, string>;
-};
-export default function ([command, ...args]: string[], options: ExecuteOptions): void;

package/dist/execute.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
-const readline = require("readline");
-const cross_spawn_1 = require("cross-spawn");
-const colors_1 = require("./utils/colors");
-const watcher_1 = require("./watcher");
-function default_1([command, ...args], options) {
-    var _a, _b;
-    if (options.readlineReload) {
-        readline.emitKeypressEvents(process.stdin);
-        (_b = (_a = process.stdin).setRawMode) === null || _b === void 0 ? void 0 : _b.call(_a, true);
-        process.stdin.on('keypress', (_, key) => {
-            if (key.name === 'f5')
-                return runProcess();
-            if ((key.ctrl || key.meta) && key.name === 'r')
-                return runProcess();
-            if (key.ctrl && key.name === 'c') {
-                killProcess();
-                console.log('^C...');
-                process.exit(0);
-            }
-        });
-    }
-    if (options.watch) {
-        (0, watcher_1.default)(options.cwd, {
-            ignore: options.watchIgnore,
-            debounceDelay: options.watchDelay,
-            extensions: new Set(options.watchExtensions),
-        }, () => runProcess());
-    }
-    let child = null;
-    function runProcess() {
-        if (options.clearOnReload) {
-            process.stdout.write('\x1Bc');
-            console.clear();
-        }
-        killProcess();
-        child = (0, cross_spawn_1.spawn)(command, args, {
-            shell: false,
-            cwd: options.cwd,
-            stdio: 'inherit',
-            env: Object.assign({}, options.env),
-        });
-        child.on('error', console.error);
-        child.on('exit', (code) => {
-            if (code && code > 0) {
-                console.log('');
-                console.log(colors_1.default.red(`Process exited with code: ${colors_1.default.yellow(String(code))}`));
-            }
-            if (options.readlineReload) {
-                console.log(colors_1.default.blue.dim(`⟳ Press ${colors_1.default.yellow('F5')} or ${colors_1.default.yellow('^R')} to reload...`));
-            }
-        });
-    }
-    function killProcess() {
-        if (child) {
-            child.removeAllListeners();
-            child.kill();
-        }
-    }
-    runProcess();
-    process.on('exit', killProcess);
-    process.on('SIGINT', killProcess);
-    process.on('cleanup', killProcess);
-}