From 8ead08df564add0c6bceeba53adefe788e64b5bb Mon Sep 17 00:00:00 2001
From: Yagiz Nizipli <yagiz@nizipli.com>
Date: Sat, 20 Apr 2024 09:31:02 -0400
Subject: [PATCH] src: rewrite task runner in c++

---
 lib/internal/main/run.js              |  74 ---------
 lib/internal/shell.js                 |  37 -----
 node.gyp                              |   2 +
 src/node.cc                           |  21 ++-
 src/node_modules.cc                   |  24 ---
 src/node_options.cc                   |   9 +-
 src/node_options.h                    |   2 +-
 src/node_task_runner.cc               | 221 ++++++++++++++++++++++++++
 src/node_task_runner.h                |  49 ++++++
 test/cctest/test_node_task_runner.cc  |  27 ++++
 test/message/node_run_non_existent.js |   2 +-
 test/parallel/test-node-run.js        |  40 +----
 12 files changed, 327 insertions(+), 181 deletions(-)
 delete mode 100644 lib/internal/main/run.js
 delete mode 100644 lib/internal/shell.js
 create mode 100644 src/node_task_runner.cc
 create mode 100644 src/node_task_runner.h
 create mode 100644 test/cctest/test_node_task_runner.cc

diff --git a/lib/internal/main/run.js b/lib/internal/main/run.js
deleted file mode 100644
index 900e73d2810357..00000000000000
--- a/lib/internal/main/run.js
+++ /dev/null
@@ -1,74 +0,0 @@
-'use strict';
-/* eslint-disable node-core/prefer-primordials */
-
-// There is no need to add primordials to this file.
-// `run.js` is a script only executed when `node --run <script>` is called.
-const {
-  prepareMainThreadExecution,
-  markBootstrapComplete,
-} = require('internal/process/pre_execution');
-const { getPackageJSONScripts } = internalBinding('modules');
-const { execSync } = require('child_process');
-const { resolve, delimiter } = require('path');
-const { escapeShell } = require('internal/shell');
-const { getOptionValue } = require('internal/options');
-const { emitExperimentalWarning } = require('internal/util');
-
-prepareMainThreadExecution(false, false);
-markBootstrapComplete();
-emitExperimentalWarning('Task runner');
-
-// TODO(@anonrig): Search for all package.json's until root folder.
-const json_string = getPackageJSONScripts();
-
-// Check if package.json exists and is parseable
-if (json_string === undefined) {
-  process.exitCode = 1;
-  return;
-}
-const scripts = JSON.parse(json_string);
-// Remove the first argument, which are the node binary.
-const args = process.argv.slice(1);
-const id = getOptionValue('--run');
-let command = scripts[id];
-
-if (!command) {
-  const { error } = require('internal/console/global');
-
-  error(`Missing script: "${id}"\n`);
-
-  const keys = Object.keys(scripts);
-  if (keys.length === 0) {
-    error('There are no scripts available in package.json');
-  } else {
-    error('Available scripts are:');
-    for (const script of keys) {
-      error(`  ${script}: ${scripts[script]}`);
-    }
-  }
-  process.exit(1);
-  return;
-}
-
-const env = process.env;
-const cwd = process.cwd();
-const binPath = resolve(cwd, 'node_modules/.bin');
-
-// Filter all environment variables that contain the word "path"
-const keys = Object.keys(env).filter((key) => /^path$/i.test(key));
-const PATH = keys.map((key) => env[key]);
-
-// Append only the current folder bin path to the PATH variable.
-// TODO(@anonrig): Prepend the bin path of all parent folders.
-const paths = [binPath, PATH].join(delimiter);
-for (const key of keys) {
-  env[key] = paths;
-}
-
-// If there are any remaining arguments left, append them to the command.
-// This is useful if you want to pass arguments to the script, such as
-// `node --run linter -- --help` which runs `biome --check . --help`
-if (args.length > 0) {
-  command += ' ' + escapeShell(args.map((arg) => arg.trim()).join(' '));
-}
-execSync(command, { stdio: 'inherit', env, shell: true });
diff --git a/lib/internal/shell.js b/lib/internal/shell.js
deleted file mode 100644
index 144fd9e98dcd0c..00000000000000
--- a/lib/internal/shell.js
+++ /dev/null
@@ -1,37 +0,0 @@
-'use strict';
-
-
-// There is no need to add primordials to this file.
-// `shell.js` is a script only executed when `node run <script>` is called.
-
-const forbiddenCharacters = /[\t\n\r "#$&'()*;<>?\\`|~]/;
-
-/**
- * Escapes a string to be used as a shell argument.
- *
- * Adapted from `promise-spawn` module available under ISC license.
- * Ref: https://github.com/npm/promise-spawn/blob/16b36410f9b721dbe190141136432a418869734f/lib/escape.js
- * @param {string} input
- */
-function escapeShell(input) {
-  // If the input is an empty string, return a pair of quotes
-  if (!input.length) {
-    return '\'\'';
-  }
-
-  // Check if input contains any forbidden characters
-  // If it doesn't, return the input as is.
-  if (!forbiddenCharacters.test(input)) {
-    return input;
-  }
-
-  // Replace single quotes with '\'' and wrap the whole result in a fresh set of quotes
-  return `'${input.replace(/'/g, '\'\\\'\'')}'`
-    // If the input string already had single quotes around it, clean those up
-    .replace(/^(?:'')+(?!$)/, '')
-    .replace(/\\'''/g, '\\\'');
-}
-
-module.exports = {
-  escapeShell,
-};
diff --git a/node.gyp b/node.gyp
index bddbdc5a24c9ff..d449145e3a94da 100644
--- a/node.gyp
+++ b/node.gyp
@@ -136,6 +136,7 @@
       'src/node_stat_watcher.cc',
       'src/node_symbols.cc',
       'src/node_task_queue.cc',
+      'src/node_task_runner.cc',
       'src/node_trace_events.cc',
       'src/node_types.cc',
       'src/node_url.cc',
@@ -397,6 +398,7 @@
       'test/cctest/test_base_object_ptr.cc',
       'test/cctest/test_cppgc.cc',
       'test/cctest/test_node_postmortem_metadata.cc',
+      'test/cctest/test_node_task_runner.cc',
       'test/cctest/test_environment.cc',
       'test/cctest/test_linked_binding.cc',
       'test/cctest/test_node_api.cc',
diff --git a/src/node.cc b/src/node.cc
index 5d730985bfea4a..5831dba0975e7e 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -21,6 +21,7 @@
 
 #include "node.h"
 #include "node_dotenv.h"
+#include "node_task_runner.h"
 
 // ========== local headers ==========
 
@@ -409,10 +410,6 @@ MaybeLocal<Value> StartExecution(Environment* env, StartExecutionCallback cb) {
     return StartExecution(env, "internal/main/watch_mode");
   }
 
-  if (!env->options()->run.empty()) {
-    return StartExecution(env, "internal/main/run");
-  }
-
   if (!first_argv.empty() && first_argv != "-") {
     return StartExecution(env, "internal/main/run_main_module");
   }
@@ -1059,6 +1056,22 @@ InitializeOncePerProcessInternal(const std::vector<std::string>& args,
     }
   }
 
+  if (!per_process::cli_options->run.empty()) {
+    // TODO(@anonrig): Handle NODE_NO_WARNINGS, NODE_REDIRECT_WARNINGS,
+    //  --disable-warning and --redirect-warnings.
+    if (per_process::cli_options->per_isolate->per_env->warnings) {
+      fprintf(stderr,
+              "ExperimentalWarning: Task runner is an experimental feature and "
+              "might change at any time\n\n");
+    }
+
+    auto positional_args = task_runner::GetPositionalArgs(args);
+    result->early_return_ = true;
+    task_runner::RunTask(
+        &result, per_process::cli_options->run, positional_args);
+    return result;
+  }
+
   if (!(flags & ProcessInitializationFlags::kNoPrintHelpOrVersionOutput)) {
     if (per_process::cli_options->print_version) {
       printf("%s\n", NODE_VERSION);
diff --git a/src/node_modules.cc b/src/node_modules.cc
index 0ac38eaf9b1859..60fc116f5fecbb 100644
--- a/src/node_modules.cc
+++ b/src/node_modules.cc
@@ -367,28 +367,6 @@ void BindingData::GetNearestParentPackageJSONType(
   args.GetReturnValue().Set(Array::New(realm->isolate(), values, 3));
 }
 
-void BindingData::GetPackageJSONScripts(
-    const FunctionCallbackInfo<Value>& args) {
-  Realm* realm = Realm::GetCurrent(args);
-  std::string_view path = "package.json";
-
-  THROW_IF_INSUFFICIENT_PERMISSIONS(
-      realm->env(), permission::PermissionScope::kFileSystemRead, path);
-
-  auto package_json = GetPackageJSON(realm, path);
-  if (package_json == nullptr) {
-    printf("Can't read package.json\n");
-    return;
-  } else if (!package_json->scripts.has_value()) {
-    printf("Can't read package.json \"scripts\" object\n");
-    return;
-  }
-
-  args.GetReturnValue().Set(
-      ToV8Value(realm->context(), package_json->scripts.value())
-          .ToLocalChecked());
-}
-
 void BindingData::GetPackageScopeConfig(
     const FunctionCallbackInfo<Value>& args) {
   CHECK_GE(args.Length(), 1);
@@ -469,7 +447,6 @@ void BindingData::CreatePerIsolateProperties(IsolateData* isolate_data,
             "getNearestParentPackageJSON",
             GetNearestParentPackageJSON);
   SetMethod(isolate, target, "getPackageScopeConfig", GetPackageScopeConfig);
-  SetMethod(isolate, target, "getPackageJSONScripts", GetPackageJSONScripts);
 }
 
 void BindingData::CreatePerContextProperties(Local<Object> target,
@@ -486,7 +463,6 @@ void BindingData::RegisterExternalReferences(
   registry->Register(GetNearestParentPackageJSONType);
   registry->Register(GetNearestParentPackageJSON);
   registry->Register(GetPackageScopeConfig);
-  registry->Register(GetPackageJSONScripts);
 }
 
 }  // namespace modules
diff --git a/src/node_options.cc b/src/node_options.cc
index ba347328efc5e9..71100894ff1c0e 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -574,10 +574,7 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "process V8 profiler output generated using --prof",
             &EnvironmentOptions::prof_process);
   // Options after --prof-process are passed through to the prof processor.
-  AddAlias("--prof-process", { "--prof-process", "--" });
-  AddOption("--run",
-            "Run a script specified in package.json",
-            &EnvironmentOptions::run);
+  AddAlias("--prof-process", {"--prof-process", "--"});
 #if HAVE_INSPECTOR
   AddOption("--cpu-prof",
             "Start the V8 CPU profiler on start up, and write the CPU profile "
@@ -1081,6 +1078,10 @@ PerProcessOptionsParser::PerProcessOptionsParser(
             "Generate a blob that can be embedded into the single executable "
             "application",
             &PerProcessOptions::experimental_sea_config);
+
+  AddOption("--run",
+            "Run a script specified in package.json",
+            &PerProcessOptions::run);
 }
 
 inline std::string RemoveBrackets(const std::string& host) {
diff --git a/src/node_options.h b/src/node_options.h
index cf744f13cd8f59..30e7681c5de16d 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -162,7 +162,6 @@ class EnvironmentOptions : public Options {
   bool heap_prof = false;
 #endif  // HAVE_INSPECTOR
   std::string redirect_warnings;
-  std::string run;
   std::string diagnostic_dir;
   std::string env_file;
   bool has_env_file_string = false;
@@ -282,6 +281,7 @@ class PerProcessOptions : public Options {
   bool print_v8_help = false;
   bool print_version = false;
   std::string experimental_sea_config;
+  std::string run;
 
 #ifdef NODE_HAVE_I18N_SUPPORT
   std::string icu_data_dir;
diff --git a/src/node_task_runner.cc b/src/node_task_runner.cc
new file mode 100644
index 00000000000000..6bd8ca83d33900
--- /dev/null
+++ b/src/node_task_runner.cc
@@ -0,0 +1,221 @@
+#include "node_task_runner.h"
+#include "util.h"
+
+#include <regex>  // NOLINT(build/c++11)
+
+namespace node::task_runner {
+
+#ifdef _WIN32
+static const char separator[] = "\\";
+static const char bin_path[] = "node_modules\\.bin";
+static const char task_file[] = "cmd.exe";
+#else
+static const char separator[] = "/";
+static const char bin_path[] = "node_modules/.bin";
+static const char task_file[] = "/bin/sh";
+#endif  // _WIN32
+
+ProcessRunner::ProcessRunner(
+    std::unique_ptr<InitializationResultImpl>* result,
+    std::string_view command,
+    const std::optional<std::string>& positional_args) {
+  process_ = {};
+  loop = uv_default_loop();
+  memset(&options, 0, sizeof(uv_process_options_t));
+
+  // Inherit stdin, stdout, and stderr from the parent process.
+  options.stdio_count = 3;
+  child_stdio[0].flags = UV_INHERIT_FD;
+  child_stdio[0].data.fd = 0;
+  child_stdio[1].flags = UV_INHERIT_FD;
+  child_stdio[1].data.fd = 1;
+  child_stdio[2].flags = UV_INHERIT_FD;
+  child_stdio[2].data.fd = 2;
+  options.stdio = child_stdio;
+  options.exit_cb = ExitCallback;
+  options.file = task_file;
+
+  init_result = result;
+  process_.data = this;
+
+  // Get the current working directory.
+  char cwd[PATH_MAX_BYTES];
+  size_t cwd_size = PATH_MAX_BYTES;
+  CHECK_EQ(uv_cwd(cwd, &cwd_size), 0);
+  CHECK_GT(cwd_size, 0);
+
+  // Example: "/Users/user/project/node_modules/.bin"
+  std::string current_bin_path = cwd + std::string(separator) + bin_path;
+
+  std::string command_str(command);
+  // Conditionally append the positional arguments to the command string
+  if (positional_args.has_value()) {
+    // Properly escape the positional arguments
+    command_str += " " + EscapeShell(positional_args.value());
+  }
+
+  // Example: "/bin/sh -c 'node test.js'"
+  std::vector<std::string> command_args = {options.file, "-c", command_str};
+  auto argc = command_args.size();
+  CHECK_GE(argc, 1);
+  options.args = new char*[argc + 1];
+  for (size_t i = 0; i < argc; ++i) {
+    options.args[i] = new char[command_args[i].size() + 1];
+    strcpy(options.args[i], command_args[i].c_str());
+  }
+  options.args[argc] = nullptr;
+
+  // Set environment variables
+  uv_env_item_t* env_items;
+  int env_count;
+  CHECK_EQ(uv_os_environ(&env_items, &env_count), 0);
+  options.env =
+      reinterpret_cast<char**>(malloc(sizeof(char*) * (env_count + 1)));
+
+  for (int i = 0; i < env_count; i++) {
+    std::string name = env_items[i].name;
+    std::string value = env_items[i].value;
+    // Check if environment variable key is matching case-insensitive "path"
+    if (name.size() == 4 && StringEqualNoCaseN(name.c_str(), "path", 4)) {
+      value.insert(0, current_bin_path + ":");
+    }
+    value.insert(0, name + "=");
+    // Environment variables should be in "KEY=value" format
+    options.env[i] = strdup(value.c_str());
+  }
+  options.env[env_count] = nullptr;
+}
+
+std::string EscapeShell(const std::string& input) {
+  // If the input is an empty string, return a pair of quotes
+  if (input.empty()) {
+    return "''";
+  }
+
+  static const std::string_view forbidden_characters =
+      "[\t\n\r \"#$&'()*;<>?\\\\`|~]";
+
+  // Check if input contains any forbidden characters
+  // If it doesn't, return the input as is.
+  if (input.find_first_of(forbidden_characters) == std::string::npos) {
+    return input;
+  }
+
+  // Replace single quotes("'") with "\\'"
+  std::string escaped = std::regex_replace(input, std::regex("'"), "\\'");
+
+  // Wrap the result in single quotes
+  escaped = "'" + escaped + "'";
+
+  // Remove excessive quote pairs and handle edge cases
+  static const std::regex leadingQuotePairs("^(?:'')+(?!$)");
+  static const std::regex tripleSingleQuote("\\\\'''");
+
+  escaped = std::regex_replace(escaped, leadingQuotePairs, "");
+  escaped = std::regex_replace(escaped, tripleSingleQuote, "\\'");
+
+  return escaped;
+}
+
+void ProcessRunner::ExitCallback(uv_process_t* handle,
+                                 int64_t exit_status,
+                                 int term_signal) {
+  auto self = reinterpret_cast<ProcessRunner*>(handle->data);
+  uv_close(reinterpret_cast<uv_handle_t*>(handle), nullptr);
+  self->OnExit(exit_status, term_signal);
+}
+
+void ProcessRunner::OnExit(int64_t exit_status, int term_signal) {
+  if (exit_status > 0) {
+    init_result->get()->exit_code_ = ExitCode::kGenericUserError;
+  } else {
+    init_result->get()->exit_code_ = ExitCode::kNoFailure;
+  }
+}
+
+void ProcessRunner::Run() {
+  if (int r = uv_spawn(loop, &process_, &options)) {
+    fprintf(stderr, "Error: %s\n", uv_strerror(r));
+  }
+
+  uv_run(loop, UV_RUN_DEFAULT);
+}
+
+void RunTask(std::unique_ptr<InitializationResultImpl>* result,
+             std::string_view command_id,
+             const std::optional<std::string>& positional_args) {
+  std::string_view path = "package.json";
+  std::string raw_json;
+
+  // No need to exclude BOM since simdjson will skip it.
+  if (ReadFileSync(&raw_json, path.data()) < 0) {
+    fprintf(stderr, "Can't read package.json\n");
+    result->get()->exit_code_ = ExitCode::kGenericUserError;
+    return;
+  }
+
+  simdjson::ondemand::parser json_parser;
+  simdjson::ondemand::document document;
+  simdjson::ondemand::object main_object;
+  simdjson::error_code error = json_parser.iterate(raw_json).get(document);
+
+  // If document is not an object, throw an error.
+  if (error || document.get_object().get(main_object)) {
+    fprintf(stderr, "Can't parse package.json\n");
+    result->get()->exit_code_ = ExitCode::kGenericUserError;
+    return;
+  }
+
+  // If package_json object doesn't have "scripts" field, throw an error.
+  simdjson::ondemand::object scripts_object;
+  if (main_object.find_field("scripts").get_object().get(scripts_object)) {
+    fprintf(stderr, "Can't find \"scripts\" field in package.json\n");
+    result->get()->exit_code_ = ExitCode::kGenericUserError;
+    return;
+  }
+
+  // If the command_id is not found in the scripts object, throw an error.
+  std::string_view command;
+  if (scripts_object.find_field(command_id).get_string().get(command)) {
+    fprintf(stderr, "Missing script: \"%s\"\n\n", command_id.data());
+    fprintf(stderr, "Available scripts are:\n");
+
+    // Reset the object to iterate over it again
+    scripts_object.reset();
+    simdjson::ondemand::value value;
+    for (auto field : scripts_object) {
+      std::string_view key_str;
+      std::string_view value_str;
+      if (!field.unescaped_key().get(key_str) && !field.value().get(value) &&
+          !value.get_string().get(value_str)) {
+        fprintf(stderr,
+                "  %s: %s\n",
+                std::string(key_str).c_str(),
+                std::string(value_str).c_str());
+      }
+    }
+    result->get()->exit_code_ = ExitCode::kGenericUserError;
+    return;
+  }
+
+  auto runner = ProcessRunner(result, command, positional_args);
+  runner.Run();
+}
+
+std::optional<std::string> GetPositionalArgs(
+    const std::vector<std::string>& args) {
+  // If the "--" flag is not found, return an empty optional
+  // Otherwise, return the positional arguments as a single string
+  if (auto dash_dash = std::find(args.begin(), args.end(), "--");
+      dash_dash != args.end()) {
+    std::string positional_args;
+    for (auto it = dash_dash + 1; it != args.end(); ++it) {
+      positional_args += it->c_str();
+    }
+    return positional_args;
+  }
+
+  return std::nullopt;
+}
+
+}  // namespace node::task_runner
diff --git a/src/node_task_runner.h b/src/node_task_runner.h
new file mode 100644
index 00000000000000..40056e517c7643
--- /dev/null
+++ b/src/node_task_runner.h
@@ -0,0 +1,49 @@
+#ifndef SRC_NODE_TASK_RUNNER_H_
+#define SRC_NODE_TASK_RUNNER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_internals.h"
+#include "simdjson.h"
+#include "spawn_sync.h"
+#include "uv.h"
+
+#include <optional>
+#include <string_view>
+
+namespace node {
+namespace task_runner {
+
+class ProcessRunner {
+ public:
+  ProcessRunner(std::unique_ptr<InitializationResultImpl>* result,
+                std::string_view command_id,
+                const std::optional<std::string>& positional_args);
+  void Run();
+  static void ExitCallback(uv_process_t* req,
+                           int64_t exit_status,
+                           int term_signal);
+
+ private:
+  uv_loop_t* loop;
+  uv_process_t process_;
+  uv_process_options_t options;
+  uv_stdio_container_t child_stdio[3];
+  std::unique_ptr<InitializationResultImpl>* init_result;
+
+  void OnExit(int64_t exit_status, int term_signal);
+};
+
+void RunTask(std::unique_ptr<InitializationResultImpl>* result,
+             std::string_view command_id,
+             const std::optional<std::string>& positional_args);
+std::optional<std::string> GetPositionalArgs(
+    const std::vector<std::string>& args);
+std::string EscapeShell(const std::string& command);
+
+}  // namespace task_runner
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_TASK_RUNNER_H_
diff --git a/test/cctest/test_node_task_runner.cc b/test/cctest/test_node_task_runner.cc
new file mode 100644
index 00000000000000..5e30b979f3d1d7
--- /dev/null
+++ b/test/cctest/test_node_task_runner.cc
@@ -0,0 +1,27 @@
+#include "gtest/gtest.h"
+#include "node_task_runner.h"
+#include "node_test_fixture.h"
+
+#include <tuple>
+#include <vector>
+
+class TaskRunnerTest : public EnvironmentTestFixture {};
+
+TEST_F(TaskRunnerTest, EscapeShell) {
+  std::vector<std::pair<std::string, std::string>> expectations = {
+      {"", "''"},
+      {"test", "test"},
+      {"test words", "'test words'"},
+      {"$1", "'$1'"},
+      {"\"$1\"", "'\"$1\"'"},
+      {"'$1'", "'\\'$1\\''"},
+      {"\\$1", "'\\$1'"},
+      {"--arg=\"$1\"", "'--arg=\"$1\"'"},
+      {"--arg=node exec -c \"$1\"", "'--arg=node exec -c \"$1\"'"},
+      {"--arg=node exec -c '$1'", "'--arg=node exec -c \\'$1\\''"},
+      {"'--arg=node exec -c \"$1\"'", "'\\'--arg=node exec -c \"$1\"\\''"}};
+
+  for (const auto& [input, expected] : expectations) {
+    EXPECT_EQ(node::task_runner::EscapeShell(input), expected);
+  }
+}
diff --git a/test/message/node_run_non_existent.js b/test/message/node_run_non_existent.js
index 7c49978b43a25b..7809aa207f0ed9 100644
--- a/test/message/node_run_non_existent.js
+++ b/test/message/node_run_non_existent.js
@@ -7,7 +7,7 @@ const fixtures = require('../common/fixtures');
 
 const child = childProcess.spawnSync(
   process.execPath,
-  [ '--run', 'non-existent-command'],
+  [ '--no-warnings', '--run', 'non-existent-command'],
   { cwd: fixtures.path('run-script'), encoding: 'utf8' },
 );
 assert.strictEqual(child.status, 1);
diff --git a/test/parallel/test-node-run.js b/test/parallel/test-node-run.js
index fc727b702fde1a..ce0c21215fda58 100644
--- a/test/parallel/test-node-run.js
+++ b/test/parallel/test-node-run.js
@@ -16,7 +16,8 @@ describe('node run [command]', () => {
       { cwd: __dirname },
     );
     assert.match(child.stderr, /ExperimentalWarning: Task runner is an experimental feature and might change at any time/);
-    assert.match(child.stdout, /Can't read package\.json/);
+    assert.match(child.stderr, /Can't read package\.json/);
+    assert.strictEqual(child.stdout, '');
     assert.strictEqual(child.code, 1);
   });
 
@@ -26,8 +27,8 @@ describe('node run [command]', () => {
       [ '--no-warnings', '--run', 'test'],
       { cwd: __dirname },
     );
-    assert.match(child.stdout, /Can't read package\.json/);
-    assert.strictEqual(child.stderr, '');
+    assert.match(child.stderr, /Can't read package\.json/);
+    assert.strictEqual(child.stdout, '');
     assert.strictEqual(child.code, 1);
   });
 
@@ -63,37 +64,4 @@ describe('node run [command]', () => {
     assert.strictEqual(child.stderr, '');
     assert.strictEqual(child.code, 0);
   });
-
-  it('should support having --env-file cli flag', async () => {
-    const child = await common.spawnPromisified(
-      process.execPath,
-      [ '--no-warnings', `--env-file=${fixtures.path('run-script/.env')}`, '--run', `custom-env${envSuffix}`],
-      { cwd: fixtures.path('run-script') },
-    );
-    assert.match(child.stdout, /hello world/);
-    assert.strictEqual(child.stderr, '');
-    assert.strictEqual(child.code, 0);
-  });
-
-  it('should properly escape shell', async () => {
-    const { escapeShell } = require('internal/shell');
-
-    const expectations = [
-      ['', '\'\''],
-      ['test', 'test'],
-      ['test words', '\'test words\''],
-      ['$1', '\'$1\''],
-      ['"$1"', '\'"$1"\''],
-      ['\'$1\'', '\\\'\'$1\'\\\''],
-      ['\\$1', '\'\\$1\''],
-      ['--arg="$1"', '\'--arg="$1"\''],
-      ['--arg=node exec -c "$1"', '\'--arg=node exec -c "$1"\''],
-      ['--arg=node exec -c \'$1\'', '\'--arg=node exec -c \'\\\'\'$1\'\\\''],
-      ['\'--arg=node exec -c "$1"\'', '\\\'\'--arg=node exec -c "$1"\'\\\''],
-    ];
-
-    for (const [input, expectation] of expectations) {
-      assert.strictEqual(escapeShell(input), expectation);
-    }
-  });
 });