just-scripts 2.4.2 → 2.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "just-scripts",
-  "version": "2.4.2",
+  "version": "2.6.0",
   "description": "Just Stack Scripts",
   "keywords": [],
   "repository": {
@@ -28,11 +28,11 @@
   },
   "dependencies": {
     "chalk": "^4.0.0",
+    "cross-spawn": "^7.0.6",
     "diff-match-patch": "1.0.5",
     "fs-extra": "^11.0.0",
     "glob": "^7.1.3",
-    "just-scripts-utils": "^2.1.0",
-    "just-task": ">=1.12.0 <2.0.0",
+    "just-task": "^1.13.0",
     "prompts": "^2.4.0",
     "run-parallel-limit": "^1.0.6",
     "semver": "^7.0.0",
@@ -40,6 +40,7 @@
     "webpack-merge": "^5.7.3"
   },
   "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
     "@types/diff-match-patch": "^1.0.32",
     "@types/glob": "^7.2.0",
     "@types/prompts": "^2.4.2",

package/src/index.ts

@@ -43,4 +43,4 @@ export { copyInstructions };
 
 export * from 'just-task';
 
-export { spawn } from 'just-scripts-utils';
+export { encodeArgs, spawn } from './utils';

package/src/interfaces/PackageJson.ts

@@ -0,0 +1,16 @@
+export interface Dependencies {
+  [key: string]: string;
+}
+
+export interface PackageJson {
+  name: string;
+  description?: string;
+  dependencies?: Dependencies;
+  devDependencies?: Dependencies;
+  keywords?: string;
+  just?: {
+    /** Stack that the package is tracking */
+    stack?: string;
+  };
+  [key: string]: any;
+}

package/src/tasks/eslintTask.ts

@@ -1,5 +1,5 @@
-import { resolve, logger, resolveCwd, TaskFunction } from 'just-task';
-import { encodeArgs, spawn } from 'just-scripts-utils';
+import { resolve, resolveCwd, TaskFunction } from 'just-task';
+import { logNodeCommand, spawn } from '../utils';
 import * as fs from 'fs';
 
 /**
@@ -70,7 +70,7 @@ export function eslintTask(options: EsLintTaskOptions = {}): TaskFunction {
         eslintCmd,
         ...(files ? files : ['.']),
         ...['--ext', extensions ? extensions : '.js,.jsx,.ts,.tsx'],
-        ...(noEslintRc ? '--no-eslintrc' : []),
+        ...(noEslintRc ? ['--no-eslintrc'] : []),
         ...(eslintConfigPath ? ['--config', eslintConfigPath] : []),
         ...(eslintIgnorePath ? ['--ignore-path', eslintIgnorePath] : []),
         ...(resolvePluginsPath ? ['--resolve-plugins-relative-to', resolvePluginsPath] : []),
@@ -95,10 +95,11 @@ export function eslintTask(options: EsLintTaskOptions = {}): TaskFunction {
         env.ESLINT_USE_FLAT_CONFIG = JSON.stringify(useFlatConfig);
       }
 
-      logger.info(encodeArgs(eslintArgs).join(' '));
+      logNodeCommand(eslintArgs);
       return spawn(process.execPath, eslintArgs, { stdio: 'inherit', env });
-    } else {
-      return Promise.resolve();
     }
+
+    // undertaker apparently requires returning a promise, async function, or function that calls done()
+    return Promise.resolve();
   };
 }

package/src/tasks/jestTask.ts

@@ -1,5 +1,5 @@
 import { resolve, logger, resolveCwd, TaskFunction, argv } from 'just-task';
-import { spawn, encodeArgs, readPackageJson } from 'just-scripts-utils';
+import { spawn, readPackageJson, logNodeCommand } from '../utils';
 import { existsSync } from 'fs';
 import * as supportsColor from 'supports-color';
 
@@ -14,7 +14,15 @@ export interface JestTaskOptions {
   passWithNoTests?: boolean;
   clearCache?: boolean;
   silent?: boolean;
+  /**
+   * This is not available in jest 30+
+   * Consider updating to jest 30 and using testPathPatterns (plural) instead.
+   */
   testPathPattern?: string;
+  /**
+   * Compatible with jest 30+ only
+   */
+  testPathPatterns?: string;
   testNamePattern?: string;
   // The maximum number of workers to use in jest for parallel test execution
   maxWorkers?: number;
@@ -54,7 +62,6 @@ export function jestTask(options: JestTaskOptions = {}): TaskFunction {
 
     if ((configFileExists || packageConfigExists) && jestCmd) {
       logger.info(`Running Jest`);
-      const cmd = process.execPath;
 
       const positional = argv()._.slice(1);
 
@@ -71,20 +78,22 @@ export function jestTask(options: JestTaskOptions = {}): TaskFunction {
         ...(options.watch ? ['--watch'] : []),
         ...(options.silent ? ['--silent'] : []),
         ...(options.testPathPattern ? ['--testPathPattern', options.testPathPattern] : []),
+        ...(options.testPathPatterns ? ['--testPathPatterns', options.testPathPatterns] : []),
         ...(options.testNamePattern ? ['--testNamePattern', options.testNamePattern] : []),
-        ...(options.maxWorkers ? ['--maxWorkers', options.maxWorkers]: []),
-        ...(options.u || options.updateSnapshot ? ['--updateSnapshot'] : ['']),
+        ...(options.maxWorkers ? ['--maxWorkers', `${options.maxWorkers}`] : []),
+        ...(options.u || options.updateSnapshot ? ['--updateSnapshot'] : []),
         // Only include the positional args if `options._` wasn't specified
         // (to avoid possibly including them twice)
         ...(options._ || positional),
       ].filter(arg => !!arg) as string[];
 
-      logger.info(cmd, encodeArgs(args).join(' '));
+      logNodeCommand(args);
 
-      return spawn(cmd, args, { stdio: 'inherit', env: options.env });
-    } else {
-      logger.warn('no jest configuration found, skipping jest');
-      return Promise.resolve();
+      return spawn(process.execPath, args, { stdio: 'inherit', env: options.env });
     }
+
+    logger.warn('no jest configuration found, skipping jest');
+    // undertaker apparently requires returning a promise, async function, or function that calls done()
+    return Promise.resolve();
   };
 }

package/src/tasks/nodeExecTask.ts

@@ -1,42 +1,56 @@
 import { SpawnOptions } from 'child_process';
-import { spawn } from 'just-scripts-utils';
+import { spawn } from '../utils';
 import { logger, TaskFunction } from 'just-task';
 import { resolveCwd, _tryResolve } from 'just-task/lib/resolve';
 import { getTsNodeEnv } from '../typescript/getTsNodeEnv';
 
 export interface NodeExecTaskOptions {
   /**
-   * Arguments to be passed into a spawn call for webpack dev server. This can be used to do things
-   * like increase the heap space for the JS engine to address out of memory issues.
+   * Arguments to be passed into a spawn call, including the script path to execute.
+   * The script path should be **absolute** to prevent unpredictable resolution.
+   *
+   * **WARNING: If `options.shell` is enabled, do not pass unsanitized user input as `args`.
+   * Any input containing shell metacharacters may be used to trigger arbitrary command execution.**
    */
-  args?: string[];
+  args: string[];
 
   /**
-   * Environment variables to be passed to the webpack-cli
+   * Environment variables to be passed to the spawned process.
+   * Defaults to `process.env`.
    */
   env?: NodeJS.ProcessEnv;
 
   /**
-   * Should this nodeExec task be using something like ts-node to execute the binary
+   * Whether to use `ts-node` to execute the script
    */
   enableTypeScript?: boolean;
 
   /**
-   * The tsconfig file to pass to ts-node for Typescript config
+   * tsconfig file path to pass to `ts-node`
    */
   tsconfig?: string;
 
   /**
-   * Transpile the config only
+   * Whether to use `transpileOnly` mode for `ts-node`
    */
   transpileOnly?: boolean;
 
   /**
-   * Custom spawn options
+   * Custom spawn options.
+   *
+   * **WARNING: If the `shell` option is enabled, do not pass unsanitized user input as `args`.
+   * Any input containing shell metacharacters may be used to trigger arbitrary command execution.**
    */
   spawnOptions?: SpawnOptions;
 }
 
+/**
+ * Create a task to execute a command in a new process.
+ * Uses `cross-spawn` to avoid issues with spaces in arguments, but does not do any additional escaping.
+ *
+ * **WARNING: If the `shell` option is enabled, do not pass unsanitized user input to this task.
+ * Any input containing shell metacharacters may be used to trigger arbitrary command execution.**
+ */
 export function nodeExecTask(options: NodeExecTaskOptions): TaskFunction {
   return function () {
     const { spawnOptions, enableTypeScript, tsconfig, transpileOnly } = options;
@@ -44,17 +58,19 @@ export function nodeExecTask(options: NodeExecTaskOptions): TaskFunction {
     const tsNodeRegister = resolveCwd('ts-node/register');
     const nodeExecPath = process.execPath;
 
-    if (enableTypeScript && tsNodeRegister) {
-      options.args = options.args || [];
-      options.args.unshift(tsNodeRegister);
-      options.args.unshift('-r');
+    const args = [...(options.args || [])];
+    //  Preserve the default behavior of inheriting process.env if no options are specified
+    let env = options.env ? { ...options.env } : { ...process.env };
+    const isTS = enableTypeScript && tsNodeRegister;
 
-      options.env = { ...options.env, ...getTsNodeEnv(tsconfig, transpileOnly) };
-      logger.info('Executing [TS]: ' + [nodeExecPath, ...(options.args || [])].join(' '));
-    } else {
-      logger.info('Executing: ' + [nodeExecPath, ...(options.args || [])].join(' '));
+    if (isTS) {
+      args.unshift('-r', tsNodeRegister);
+
+      env = { ...env, ...getTsNodeEnv(tsconfig, transpileOnly) };
     }
 
-    return spawn(nodeExecPath, options.args, { stdio: 'inherit', env: options.env, ...spawnOptions });
+    logger.info([`Executing${isTS ? ' [TS]' : ''}:`, nodeExecPath, ...args].join(' '));
+
+    return spawn(nodeExecPath, args, { stdio: 'inherit', env, ...spawnOptions });
   };
 }

package/src/tasks/prettierTask.ts

@@ -1,5 +1,5 @@
 import { logger, resolve, TaskFunction } from 'just-task';
-import { spawn } from 'just-scripts-utils';
+import { logNodeCommand, spawn } from '../utils';
 import { splitArrayIntoChunks } from '../arrayUtils/splitArrayIntoChunks';
 import * as path from 'path';
 import { arrayify } from '../arrayUtils/arrayify';
@@ -16,10 +16,12 @@ export interface PrettierTaskOptions {
   files?: string[] | string;
   ignorePath?: string;
   configPath?: string;
+  check?: boolean;
 }
 
 export function prettierTask(options: PrettierTaskOptions = {}): TaskFunction {
-  const prettierBin = resolve('prettier/bin-prettier.js');
+  // check v2 or v3 path
+  const prettierBin = resolve('prettier/bin-prettier.js') || resolve('prettier/bin/prettier.cjs');
 
   if (prettierBin) {
     return function prettier() {
@@ -32,38 +34,19 @@ export function prettierTask(options: PrettierTaskOptions = {}): TaskFunction {
             options.files || path.resolve(process.cwd(), '**', '*.{ts,tsx,js,jsx,json,scss,html,yml,md}'),
           ),
         },
-        check: false,
+        check: !!options.check,
       });
     };
   }
 
-  return function () {
+  // undertaker apparently requires returning a promise, async function, or function that calls done()
+  return async () => {
     logger.warn('Prettier is not available, ignoring this task');
   };
 }
 
 export function prettierCheckTask(options: PrettierTaskOptions = {}): TaskFunction {
-  const prettierBin = resolve('prettier/bin-prettier.js');
-
-  if (prettierBin) {
-    return function prettierCheck() {
-      return runPrettierAsync({
-        prettierBin,
-        ...{ configPath: options.configPath || undefined },
-        ...{ ignorePath: options.ignorePath || undefined },
-        ...{
-          files: arrayify(
-            options.files || path.resolve(process.cwd(), '**', '*.{ts,tsx,js,jsx,json,scss,html,yml,md}'),
-          ),
-        },
-        check: true,
-      });
-    };
-  }
-
-  return function () {
-    logger.warn('Prettier is not available, ignoring this task');
-  };
+  return prettierTask({ ...options, check: true });
 }
 
 function runPrettierAsync(context: PrettierContext) {
@@ -81,7 +64,7 @@ function runPrettierAsync(context: PrettierContext) {
       ...chunk,
     ];
 
-    logger.info(process.execPath + ' ' + prettierArgs.join(' '));
+    logNodeCommand(prettierArgs);
 
     return finishPromise.then(() => spawn(process.execPath, prettierArgs, { stdio: 'inherit' }));
   }, Promise.resolve());

package/src/tasks/tscTask.ts

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 import { resolve, logger, resolveCwd, TaskFunction } from 'just-task';
-import { exec, encodeArgs, spawn } from 'just-scripts-utils';
+import { logNodeCommand, spawn } from '../utils';
 import * as fs from 'fs';
 
 export type TscTaskOptions = { [key in keyof ts.CompilerOptions]?: string | boolean | string[] } & {
@@ -25,9 +25,8 @@ export function tscTask(options: TscTaskOptions = {}): TaskFunction {
       logger.info(`Running ${tscCmd} with ${options.project || options.build}`);
 
       const args = argsFromOptions(tscCmd, options);
-      const cmd = encodeArgs([process.execPath, ...args]).join(' ');
-      logger.info(`Executing: ${cmd}`);
-      return exec(cmd);
+      logNodeCommand(args);
+      return spawn(process.execPath, args, { stdio: 'inherit' });
     }
     return Promise.resolve();
   };
@@ -37,25 +36,7 @@ export function tscTask(options: TscTaskOptions = {}): TaskFunction {
  * Returns a task that runs the TSC CLI in watch mode.
  */
 export function tscWatchTask(options: TscTaskOptions = {}): TaskFunction {
-  const tscCmd = resolve('typescript/lib/tsc.js');
-
-  if (!tscCmd) {
-    throw new Error('cannot find tsc');
-  }
-
-  return function tscWatch() {
-    options = { ...options, ...getProjectOrBuildOptions(options) };
-
-    if (isValidProject(options)) {
-      logger.info(`Running ${tscCmd} with ${options.project || options.build} in watch mode`);
-
-      const args = argsFromOptions(tscCmd, options);
-      const cmd = [...args, '--watch'];
-      logger.info(encodeArgs(cmd).join(' '));
-      return spawn(process.execPath, cmd, { stdio: 'inherit' });
-    }
-    return Promise.resolve();
-  };
+  return tscTask({ ...options, watch: true });
 }
 
 /**
@@ -81,9 +62,7 @@ function isValidProject(options: TscTaskOptions) {
     (typeof options.project === 'string' && fs.existsSync(options.project)) ||
     (typeof options.build === 'string' && fs.existsSync(options.build)) ||
     (Array.isArray(options.build) &&
-      options.build.reduce((currentIsValid, buildPath) => {
-        return currentIsValid && typeof buildPath === 'string' && fs.existsSync(buildPath);
-      }, true as boolean))
+      options.build.every(buildPath => typeof buildPath === 'string' && fs.existsSync(buildPath)))
   );
 }
 
@@ -91,23 +70,21 @@ function isValidProject(options: TscTaskOptions) {
  * Returns an array of CLI arguments for TSC given the `options`.
  */
 function argsFromOptions(tscCmd: string, options: TscTaskOptions): string[] {
-  const { nodeArgs, ...rest } = options;
+  const { nodeArgs, build, ...rest } = options;
+
+  const args = [...(nodeArgs || []), tscCmd];
+  // --build must be the first arg if specified
+  const argEntries = [...(build !== undefined ? [['build', build]] : []), ...Object.entries(rest)];
+
+  for (const [option, optionValue] of argEntries) {
+    if (typeof optionValue === 'string') {
+      args.push('--' + option, optionValue);
+    } else if (typeof optionValue === 'boolean' && optionValue) {
+      args.push('--' + option);
+    } else if (Array.isArray(optionValue)) {
+      args.push('--' + option, ...optionValue);
+    }
+  }
 
-  return [
-    ...(nodeArgs ? nodeArgs : []),
-    ...Object.keys(rest).reduce(
-      (currentArgs, option) => {
-        const optionValue = options[option];
-        if (typeof optionValue === 'string') {
-          return currentArgs.concat(['--' + option, optionValue]);
-        } else if (typeof optionValue === 'boolean' && optionValue) {
-          return currentArgs.concat(['--' + option]);
-        } else if (Array.isArray(optionValue)) {
-          return currentArgs.concat(['--' + option, ...optionValue]);
-        }
-        return currentArgs;
-      },
-      [tscCmd],
-    ),
-  ];
+  return args;
 }

package/src/tasks/tslintTask.ts

@@ -1,7 +1,7 @@
 import { resolve, logger, resolveCwd, TaskFunction } from 'just-task';
-import { exec, encodeArgs } from 'just-scripts-utils';
 import * as path from 'path';
 import * as fs from 'fs';
+import { logNodeCommand, spawn } from '../utils';
 
 export interface TsLintTaskOptions {
   config?: string;
@@ -12,7 +12,7 @@ export interface TsLintTaskOptions {
 export function tslintTask(options: TsLintTaskOptions = {}): TaskFunction {
   const projectFile = options.project || resolveCwd('./tsconfig.json');
 
-  return function tslint() {
+  return async function tslint() {
     const tslintCmd = resolve('tslint/lib/tslintCli.js');
 
     if (projectFile && tslintCmd && fs.existsSync(projectFile)) {
@@ -31,11 +31,12 @@ export function tslintTask(options: TsLintTaskOptions = {}): TaskFunction {
         args.push('--fix');
       }
 
-      const cmd = encodeArgs([process.execPath, tslintCmd, ...args]).join(' ');
-      logger.info(cmd);
-      return exec(cmd, { stdout: process.stdout, stderr: process.stderr });
-    } else {
-      return Promise.resolve();
+      const allArgs = [tslintCmd, ...args];
+      logNodeCommand(allArgs);
+      return spawn(process.execPath, allArgs, { stdio: 'inherit' });
     }
+
+    // undertaker apparently requires returning a promise, async function, or function that calls done()
+    return Promise.resolve();
   };
 }

package/src/tasks/webpackCliInitTask.ts

@@ -9,7 +9,7 @@ import { tryRequire } from '../tryRequire';
  */
 export function webpackCliInitTask(customScaffold?: string, auto = false): TaskFunction {
   return function webpackCli() {
-    const init = tryRequire('@webpack-cli/init').default;
+    const init = tryRequire('@webpack-cli/init')?.default;
     if (!init) {
       logger.warn('webpack-cli init requires three dependencies: @webpack-cli/init (preferred - as a devDependency)');
       return;

package/src/tasks/webpackCliTask.ts

@@ -1,5 +1,5 @@
 import { logger, TaskFunction, resolve } from 'just-task';
-import { spawn } from 'just-scripts-utils';
+import { logNodeCommand, spawn } from '../utils';
 import { getTsNodeEnv } from '../typescript/getTsNodeEnv';
 import { findWebpackConfig } from '../webpack/findWebpackConfig';
 
@@ -67,7 +67,7 @@ export function webpackCliTask(options: WebpackCliTaskOptions = {}): TaskFunctio
       }
     }
 
-    logger.info(`webpack-cli arguments: ${process.execPath} ${args.join(' ')}`);
+    logNodeCommand(args);
 
     return spawn(process.execPath, args, { stdio: 'inherit', env: options.env });
   };

package/src/tasks/webpackDevServerTask.ts

@@ -1,7 +1,7 @@
 // // WARNING: Careful about add more imports - only import types from webpack
 import { Configuration } from 'webpack';
-import { encodeArgs, spawn } from 'just-scripts-utils';
-import { logger, resolve, resolveCwd, TaskFunction } from 'just-task';
+import { logNodeCommand, spawn } from '../utils';
+import { resolve, resolveCwd, TaskFunction } from 'just-task';
 import * as fs from 'fs';
 import * as path from 'path';
 import { WebpackCliTaskOptions } from './webpackCliTask';
@@ -93,7 +93,7 @@ export function webpackDevServerTask(options: WebpackDevServerTaskOptions = {}):
       args = [...args, ...options.webpackCliArgs];
     }
 
-    logger.info(process.execPath, encodeArgs(args).join(' '));
+    logNodeCommand(args);
     return spawn(process.execPath, args, { stdio: 'inherit', env: options.env });
   };
 }

package/src/utils/exec.ts

@@ -0,0 +1,112 @@
+import * as cp from 'child_process';
+import { spawn as crossSpawn } from 'cross-spawn';
+import { logger } from 'just-task';
+
+// `exec` and `execSync` were removed due to security issues (keeping filename for history)
+
+/**
+ * @deprecated This prevents issues from spaces in args, but does NOT escape shell metacharacters.
+ * For full escaping, consider a library such as `shell-quote` instead. (Note that `spawn` and tasks
+ * from this package now use `cross-spawn` which escapes spaces internally.)
+ */
+export function encodeArgs(cmdArgs: string[]): string[] {
+  return quoteSpaces(cmdArgs);
+}
+
+/**
+ * Quote arguments containing spaces. Note that this does NOT do any other escaping!
+ * For more complete escaping, consider a library such as `shell-quote`, or use safer APIs which
+ * don't require escaping. (Note that `spawn` from this package now uses `cross-spawn` which
+ * escapes spaces internally.)
+ */
+function quoteSpaces(cmdArgs: string[]): string[] {
+  // Taken from https://github.com/xxorax/node-shell-escape/blob/master/shell-escape.js
+  // However, we needed to use double quotes because that's the norm in more platforms
+  if (!cmdArgs) {
+    return cmdArgs;
+  }
+
+  return cmdArgs.map(arg => {
+    if (/[^\w/:=-]/.test(arg)) {
+      arg = `"${arg.replace(/"/g, '"\\"')}"`;
+      arg = arg.replace(/^(?:"")+/g, '').replace(/\\"""/g, '\\"');
+    }
+
+    return arg;
+  });
+}
+
+/**
+ * Log `Running: <process.execPath> <...args>`
+ */
+export function logNodeCommand(...args: (string | string[])[]): void {
+  logger.info(`Running: ${process.execPath} ${quoteSpaces(args.flat()).join(' ')}`);
+}
+
+/**
+ * Execute a command in a new process. Uses `cross-spawn` to avoid issues with spaces in arguments,
+ * but does not do any additional escaping. (For further enhancements, consider using the `execa`
+ * library instead.)
+ *
+ * **WARNING: If the `shell` option is enabled, do not pass unsanitized user input to this function.
+ * Any input containing shell metacharacters may be used to trigger arbitrary command execution.**
+ *
+ * @param cmd Command to execute
+ * @param args Args for the command. Quoting spaces is handled internally by `cross-spawn`.
+ * @param opts Normal spawn options plus stdout/stderr for piping output. (To inherit stdio from the
+ * parent process, just use `stdio: 'inherit'` instead.)
+ *
+ * @returns Promise which will settle when the command completes. If the promise is rejected, the error will
+ * include the child process's exit code (`error.code`) or signal (`error.signal`) if relevant.
+ * The returned promise also has a `child` property with the spawned `ChildProcess` instance.
+ *
+ * @deprecated This function is not recommended for use outside the `just-scripts` package.
+ * Instead, consider a more mature, purpose-specific library such as `execa` or `nano-spawn`.
+ */
+export function spawn(
+  cmd: string,
+  args: ReadonlyArray<string> = [],
+  opts: cp.SpawnOptions & { stdout?: NodeJS.WritableStream; stderr?: NodeJS.WritableStream } = {},
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    let child: cp.ChildProcess;
+    try {
+      child = crossSpawn(cmd, args, opts);
+    } catch (error) {
+      reject(error);
+      return;
+    }
+
+    const onExit = (code: number | null, signal: NodeJS.Signals | null): void => {
+      child.off('error', onError);
+      if (code) {
+        const error = new Error('Command failed: ' + [cmd, ...args].join(' '));
+        (error as any).code = code;
+        reject(error);
+      } else if (signal) {
+        const error = new Error(`Command terminated by signal ${signal}: ` + [cmd, ...args].join(' '));
+        (error as any).signal = signal;
+        reject(error);
+      } else {
+        resolve();
+      }
+    };
+
+    // Some error circumstances may fire 'error' rather than 'exit'
+    // https://nodejs.org/docs/latest/api/child_process.html#event-error
+    const onError = (error: Error): void => {
+      reject(error);
+      child.off('exit', onExit);
+    };
+
+    child.on('exit', onExit);
+    child.on('error', onError);
+
+    if (opts.stdout) {
+      child.stdout?.pipe(opts.stdout);
+    }
+    if (opts.stderr) {
+      child.stderr?.pipe(opts.stderr);
+    }
+  });
+}

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export * from './exec';
+export { mergePackageJson } from './mergePackageJson';
+export * from './paths';
+export * from './readPackageJson';