std::unique_ptr<inspector::ParentInspectorHandle> parent_handle) {

std::string inspector_path;

bool is_main = !parent_handle;

if (parent_handle) {

inspector_path = parent_handle->url();

inspector_agent_->SetParentHandle(std::move(parent_handle));

} else {

inspector_path = argv_.size() > 1 ? argv_[1].c_str() : "";

}

CHECK(!inspector_agent_->IsListening());

// Inspector agent can't fail to start, but if it was configured to listen

// right away on the websocket port and fails to bind/etc, this will return

// false.

inspector_agent_->Start(inspector_path,

options_->debug_options(),

inspector_host_port(),

is_main);

if (options_->debug_options().inspector_enabled &&

!inspector_agent_->IsListening()) {

return;

}

if (should_wait_for_inspector_frontend()) {

WaitForInspectorFrontendByOptions();

}

profiler::StartProfilers(this);

if (!inspector_agent_->WaitForConnectByOptions()) {

return;

}

if (inspector_agent_->options().break_node_first_line) {

inspector_agent_->PauseOnNextJavascriptStatement("Break at bootstrap");

}

return;

isolate_->GetHeapProfiler()->AddBuildEmbedderGraphCallback(

Environment::BuildEmbedderGraph, this);

if (heap_snapshot_near_heap_limit_ > 0) {

AddHeapSnapshotNearHeapLimitCallback();

}

if (options_->trace_uncaught)

isolate_->SetCaptureStackTraceForUncaughtExceptions(true);

if (options_->trace_promises) {

isolate_->SetPromiseHook(TracePromises);

}

EscapableHandleScope scope(env->isolate());

CHECK_NOT_NULL(main_script_id);

Realm* realm = env->principal_realm();

return scope.EscapeMaybe(realm->ExecuteBootstrapper(main_script_id));

Environment* env, Local<Value> result) {

CHECK(result->IsArray());

Local<Array> args = result.As<Array>();

CHECK_EQ(args->Length(), 3);

Local<Value> process_obj, require_fn, run_module;

Local<Context> context = env->context();

if (!args->Get(context, 0).ToLocal(&process_obj) ||

!args->Get(context, 1).ToLocal(&require_fn) ||

!args->Get(context, 2).ToLocal(&run_module)) {

return std::nullopt;

}

CHECK(process_obj->IsObject());

CHECK(require_fn->IsFunction());

CHECK(run_module->IsFunction());

StartExecutionCallbackInfoWithModule info;

info.set_env(env);

info.set_process_object(process_obj.As<Object>());

info.set_native_require(require_fn.As<Function>());

info.set_run_module(run_module.As<Function>());

return info;

StartExecutionCallbackWithModule cb) {

InternalCallbackScope callback_scope(

env,

Object::New(env->isolate()),

{ 1, 0 },

InternalCallbackScope::kSkipAsyncHooks);

// Only snapshot builder or embedder applications set the

// callback.

if (cb) {

EscapableHandleScope scope(env->isolate());

Local<Value> result;

if (env->isolate_data()->is_building_snapshot()) {

if (!StartExecution(env, "internal/main/mksnapshot").ToLocal(&result)) {

return MaybeLocal<Value>();

}

} else {

if (!StartExecution(env, "internal/main/embedding").ToLocal(&result)) {

return MaybeLocal<Value>();

}

}

auto info = CallbackInfoFromArray(env, result);

if (!info.has_value()) {

return MaybeLocal<Value>();

}

#if HAVE_INSPECTOR

if (env->options()->debug_options().break_first_line) {

env->inspector_agent()->PauseOnNextJavascriptStatement("Break on start");

}

#endif

env->performance_state()->Mark(

performance::NODE_PERFORMANCE_MILESTONE_BOOTSTRAP_COMPLETE);

return scope.EscapeMaybe(cb(info.value()));

}

CHECK(!env->isolate_data()->is_building_snapshot());

#ifndef DISABLE_SINGLE_EXECUTABLE_APPLICATION

// Snapshot in SEA is only loaded for the main thread.

if (sea::IsSingleExecutable() && env->is_main_thread()) {

sea::SeaResource sea = sea::FindSingleExecutableResource();

// The SEA preparation blob building process should already enforce this,

// this check is just here to guard against the unlikely case where

// the SEA preparation blob has been manually modified by someone.

CHECK_IMPLIES(sea.use_snapshot(),

!env->snapshot_deserialize_main().IsEmpty());

}

#endif

// Ignore env file if we're in watch mode.

// Without it env is not updated when restarting child process.

// Child process has --watch flag removed, so it will load the file.

if (env->options()->has_env_file_string && !env->options()->watch_mode) {

per_process::dotenv_file.SetEnvironment(env);

}

// TODO(joyeecheung): move these conditions into JS land and let the

// deserialize main function take precedence. For workers, we need to

// move the pre-execution part into a different file that can be

// reused when dealing with user-defined main functions.

if (!env->snapshot_deserialize_main().IsEmpty()) {

// Custom worker snapshot is not supported yet,

// so workers can't have deserialize main functions.

CHECK(env->is_main_thread());

return env->RunSnapshotDeserializeMain();

}

if (env->worker_context() != nullptr) {

return StartExecution(env, "internal/main/worker_thread");

}

std::string first_argv;

if (env->argv().size() > 1) {

first_argv = env->argv()[1];

}

if (first_argv == "inspect") {

return StartExecution(env, "internal/main/inspect");

}

if (per_process::cli_options->print_help) {

return StartExecution(env, "internal/main/print_help");

}

if (env->options()->prof_process) {

return StartExecution(env, "internal/main/prof_process");

}

// -e/--eval without -i/--interactive

if (env->options()->has_eval_string && !env->options()->force_repl) {

return StartExecution(env, "internal/main/eval_string");

}

if (env->options()->syntax_check_only) {

return StartExecution(env, "internal/main/check_syntax");

}

if (env->options()->test_runner) {

return StartExecution(env, "internal/main/test_runner");

}

if (env->options()->watch_mode) {

return StartExecution(env, "internal/main/watch_mode");

}

if (!first_argv.empty() && first_argv != "-") {

return StartExecution(env, "internal/main/run_main_module");

}

if (env->options()->force_repl || uv_guess_handle(STDIN_FILENO) == UV_TTY) {

return StartExecution(env, "internal/main/repl");

}

return StartExecution(env, "internal/main/eval_stdin");

if (v8::TryHandleWebAssemblyTrapWindows(exception)) {

return EXCEPTION_CONTINUE_EXECUTION;

}

return EXCEPTION_CONTINUE_SEARCH;

if (!v8::TryHandleWebAssemblyTrapPosix(signo, info, ucontext)) {

#if defined(__APPLE__)

sigaction_cb prev = signo == SIGBUS ? previous_sigbus_action.load()

: previous_sigsegv_action.load();

#else

sigaction_cb prev = previous_sigsegv_action.load();

#endif // __APPLE__

if (prev != nullptr) {

prev(signo, info, ucontext);

} else {

// Reset to the default signal handler, i.e. cause a hard crash.

struct sigaction sa;

memset(&sa, 0, sizeof(sa));

sa.sa_handler = SIG_DFL;

CHECK_EQ(sigaction(signo, &sa, nullptr), 0);

ResetStdio();

raise(signo);

}

}

sigaction_cb handler,

bool reset_handler) {

CHECK_NOT_NULL(handler);

#if NODE_USE_V8_WASM_TRAP_HANDLER

// Stash the user-registered handlers for TrapWebAssemblyOrContinue

// to call out to when the signal is not coming from a WASM OOM.

if (signal == SIGSEGV && is_wasm_trap_handler_configured.load()) {

CHECK(previous_sigsegv_action.is_lock_free());

CHECK(!reset_handler);

previous_sigsegv_action.store(handler);

return;

}

// TODO(align behavior between macos and other in next major version)

#if defined(__APPLE__)

if (signal == SIGBUS && is_wasm_trap_handler_configured.load()) {

CHECK(previous_sigbus_action.is_lock_free());

CHECK(!reset_handler);

previous_sigbus_action.store(handler);

return;

}

#endif // __APPLE__

#endif // NODE_USE_V8_WASM_TRAP_HANDLER

struct sigaction sa;

memset(&sa, 0, sizeof(sa));

sa.sa_sigaction = handler;

sa.sa_flags = reset_handler ? SA_RESETHAND : 0;

sigfillset(&sa.sa_mask);

CHECK_EQ(sigaction(signal, &sa, nullptr), 0);

#ifdef __POSIX__

// Restore signal dispositions, the parent process may have changed them.

struct sigaction act;

memset(&act, 0, sizeof(act));

// The hard-coded upper limit is because NSIG is not very reliable; on Linux,

// it evaluates to 32, 34 or 64, depending on whether RT signals are enabled.

// Counting up to SIGRTMIN doesn't work for the same reason.

for (unsigned nr = 1; nr < kMaxSignal; nr += 1) {

if (nr == SIGKILL || nr == SIGSTOP)

continue;

act.sa_handler = (nr == SIGPIPE || nr == SIGXFSZ) ? SIG_IGN : SIG_DFL;

if (act.sa_handler == SIG_DFL) {

// The only bad handler value we can inherit from before exec is SIG_IGN

// (any actual function pointer is reset to SIG_DFL during exec).

// If that's the case, we want to reset it back to SIG_DFL.

// However, it's also possible that an embeder (or an LD_PRELOAD-ed

// library) has set up own signal handler for own purposes

// (e.g. profiling). If that's the case, we want to keep it intact.

struct sigaction old;

CHECK_EQ(0, sigaction(nr, nullptr, &old));

if ((old.sa_flags & SA_SIGINFO) || old.sa_handler != SIG_IGN) continue;

}

CHECK_EQ(0, sigaction(nr, &act, nullptr));

}

#endif // __POSIX__

// init_process_flags is accessed in ResetStdio(),

// which can be called from signal handlers.

CHECK(init_process_flags.is_lock_free());

init_process_flags.store(flags);

if (!(flags & ProcessInitializationFlags::kNoStdioInitialization)) {

atexit(ResetStdio);

}

#ifdef __POSIX__

if (!(flags & ProcessInitializationFlags::kNoStdioInitialization)) {

// Disable stdio buffering, it interacts poorly with printf()

// calls elsewhere in the program (e.g., any logging from V8.)

setvbuf(stdout, nullptr, _IONBF, 0);

setvbuf(stderr, nullptr, _IONBF, 0);

// Make sure file descriptors 0-2 are valid before we start logging

// anything.

for (auto& s : stdio) {

const int fd = &s - stdio;

if (fstat(fd, &s.stat) == 0) continue;

// Anything but EBADF means something is seriously wrong. We don't

// have to special-case EINTR, fstat() is not interruptible.

if (errno != EBADF) ABORT();

// If EBADF (file descriptor doesn't exist), open /dev/null and duplicate

// its file descriptor to the invalid file descriptor. Make sure *that*

// file descriptor is valid. POSIX doesn't guarantee the next file

// descriptor open(2) gives us is the lowest available number anymore in

// POSIX.1-2017, which is why dup2(2) is needed.

int null_fd;

do {

null_fd = open("/dev/null", O_RDWR);

} while (null_fd < 0 && errno == EINTR);

if (null_fd != fd) {

int err;

do {

err = dup2(null_fd, fd);

} while (err < 0 && errno == EINTR);

CHECK_EQ(err, 0);

}

if (fstat(fd, &s.stat) < 0) ABORT();

}

}

if (!(flags & ProcessInitializationFlags::kNoDefaultSignalHandling)) {

#if HAVE_INSPECTOR

sigset_t sigmask;

sigemptyset(&sigmask);

sigaddset(&sigmask, SIGUSR1);

const int err = pthread_sigmask(SIG_SETMASK, &sigmask, nullptr);

CHECK_EQ(err, 0);

#endif // HAVE_INSPECTOR

ResetSignalHandlers();

}

if (!(flags & ProcessInitializationFlags::kNoStdioInitialization)) {

// Record the state of the stdio file descriptors so we can restore it

// on exit. Needs to happen before installing signal handlers because

// they make use of that information.

for (auto& s : stdio) {

const int fd = &s - stdio;

int err;

do {

s.flags = fcntl(fd, F_GETFL);

} while (s.flags == -1 && errno == EINTR); // NOLINT

CHECK_NE(s.flags, -1);

if (uv_guess_handle(fd) != UV_TTY) continue;

s.isatty = true;

do {

err = tcgetattr(fd, &s.termios);

} while (err == -1 && errno == EINTR); // NOLINT

CHECK_EQ(err, 0);

}

}

if (!(flags & ProcessInitializationFlags::kNoDefaultSignalHandling)) {

RegisterSignalHandler(SIGINT, SignalExit, true);

RegisterSignalHandler(SIGTERM, SignalExit, true);

}

if (!(flags & ProcessInitializationFlags::kNoAdjustResourceLimits)) {

// Raise the open file descriptor limit.

struct rlimit lim;

if (getrlimit(RLIMIT_NOFILE, &lim) == 0 && lim.rlim_cur != lim.rlim_max) {

// Do a binary search for the limit.

rlim_t min = lim.rlim_cur;

rlim_t max = 1 << 20;

// But if there's a defined upper bound, don't search, just set it.

if (lim.rlim_max != RLIM_INFINITY) {

min = lim.rlim_max;

max = lim.rlim_max;

}

do {

lim.rlim_cur = min + (max - min) / 2;

if (setrlimit(RLIMIT_NOFILE, &lim)) {

max = lim.rlim_cur;

} else {

min = lim.rlim_cur;

}

} while (min + 1 < max);

}

}

#endif // __POSIX__

#ifdef _WIN32

if (!(flags & ProcessInitializationFlags::kNoStdioInitialization)) {

for (int fd = 0; fd <= 2; ++fd) {

auto handle = reinterpret_cast<HANDLE>(_get_osfhandle(fd));

if (handle == INVALID_HANDLE_VALUE ||

GetFileType(handle) == FILE_TYPE_UNKNOWN) {

// Ignore _close result. If it fails or not depends on used Windows

// version. We will just check _open result.

_close(fd);

if (fd != _open("nul", _O_RDWR)) ABORT();

}

}

}

#endif // _WIN32

if (init_process_flags.load() &

ProcessInitializationFlags::kNoStdioInitialization) {

return;

}

uv_tty_reset_mode();

#ifdef __POSIX__

for (auto& s : stdio) {

const int fd = &s - stdio;

struct stat tmp;

if (-1 == fstat(fd, &tmp)) {

CHECK_EQ(errno, EBADF); // Program closed file descriptor.

continue;

}

bool is_same_file =

(s.stat.st_dev == tmp.st_dev && s.stat.st_ino == tmp.st_ino);

if (!is_same_file) continue; // Program reopened file descriptor.

int flags;

do

flags = fcntl(fd, F_GETFL);

while (flags == -1 && errno == EINTR); // NOLINT

CHECK_NE(flags, -1);

// Restore the O_NONBLOCK flag if it changed.

if (O_NONBLOCK & (flags ^ s.flags)) {

flags &= ~O_NONBLOCK;

flags |= s.flags & O_NONBLOCK;

int err;

do

err = fcntl(fd, F_SETFL, flags);

while (err == -1 && errno == EINTR); // NOLINT

CHECK_NE(err, -1);

}

if (s.isatty) {

sigset_t sa;

int err;

// We might be a background job that doesn't own the TTY so block SIGTTOU

// before making the tcsetattr() call, otherwise that signal suspends us.

sigemptyset(&sa);

sigaddset(&sa, SIGTTOU);

CHECK_EQ(0, pthread_sigmask(SIG_BLOCK, &sa, nullptr));

do

err = tcsetattr(fd, TCSANOW, &s.termios);

while (err == -1 && errno == EINTR); // NOLINT

CHECK_EQ(0, pthread_sigmask(SIG_UNBLOCK, &sa, nullptr));

// We don't check the return value of tcsetattr() because it can fail

// for a number of reasons, none that we can do anything about. Examples:

// - if macOS App Sandbox is enabled, tcsetattr fails with EPERM

// - if the process group is orphaned, e.g. because the user logged out,

// tcsetattr fails with EIO

}

}

#endif // __POSIX__

std::vector<std::string>* exec_args,

std::vector<std::string>* errors,

OptionEnvvarSettings settings) {

// Parse a few arguments which are specific to Node.

std::vector<std::string> v8_args;

Mutex::ScopedLock lock(per_process::cli_options_mutex);

options_parser::Parse(

args,

exec_args,

&v8_args,

per_process::cli_options.get(),

settings,

errors);

if (!errors->empty()) return ExitCode::kInvalidCommandLineArgument;

std::string revert_error;

for (const std::string& cve : per_process::cli_options->security_reverts) {

Revert(cve.c_str(), &revert_error);

if (!revert_error.empty()) {

errors->emplace_back(std::move(revert_error));

// TODO(joyeecheung): merge into kInvalidCommandLineArgument.

return ExitCode::kInvalidCommandLineArgument2;

}

}

if (per_process::cli_options->disable_proto != "delete" &&

per_process::cli_options->disable_proto != "throw" &&

per_process::cli_options->disable_proto != "") {

errors->emplace_back("invalid mode passed to --disable-proto");

// TODO(joyeecheung): merge into kInvalidCommandLineArgument.

return ExitCode::kInvalidCommandLineArgument2;

}

if (!per_process::cli_options->per_isolate->max_old_space_size_percentage

.empty()) {

v8_args.emplace_back(

"--max_old_space_size=" +

per_process::cli_options->per_isolate->max_old_space_size);

}

auto env_opts = per_process::cli_options->per_isolate->per_env;

if (std::ranges::find(v8_args, "--abort-on-uncaught-exception") !=

v8_args.end() ||

std::ranges::find(v8_args, "--abort_on_uncaught_exception") !=

v8_args.end()) {

env_opts->abort_on_uncaught_exception = true;

}

if (std::ranges::find(v8_args, "--no-js-source-phase-imports") ==

v8_args.end()) {

v8_args.emplace_back("--js-source-phase-imports");

}

// V8 aborts the process when external memory grows by more than

// --external-memory-max-reasonable-size gigabytes in a single step. That

// limit is a Chromium-oriented sanity check; allocating a buffer larger

// than it is a legitimate thing to do in Node, and should raise a

// RangeError rather than crash. Disable the check unless the user asked

// for a specific limit.

// Refs: https://github.com/nodejs/node/issues/65534

if (std::ranges::none_of(v8_args, [](const std::string& arg) {

return arg.starts_with("--external-memory-max-reasonable-size") ||

arg.starts_with("--external_memory_max_reasonable_size");

})) {

v8_args.emplace_back("--external-memory-max-reasonable-size=0");

}

#ifdef __POSIX__

// Block SIGPROF signals when sleeping in epoll_wait/kevent/etc. Avoids the

// performance penalty of frequent EINTR wakeups when the profiler is running.

// Only do this for v8.log profiling, as it breaks v8::CpuProfiler users.

if (std::ranges::find(v8_args, "--prof") != v8_args.end()) {

uv_loop_configure(uv_default_loop(), UV_LOOP_BLOCK_SIGNAL, SIGPROF);

}

#endif

std::vector<char*> v8_args_as_char_ptr(v8_args.size());

if (v8_args.size() > 0) {

for (size_t i = 0; i < v8_args.size(); ++i)

v8_args_as_char_ptr[i] = v8_args[i].data();

int argc = v8_args.size();

V8::SetFlagsFromCommandLine(&argc, v8_args_as_char_ptr.data(), true);

v8_args_as_char_ptr.resize(argc);

}

// Anything that's still in v8_argv is not a V8 or a node option.

for (size_t i = 1; i < v8_args_as_char_ptr.size(); i++)

errors->push_back("bad option: " + std::string(v8_args_as_char_ptr[i]));

if (v8_args_as_char_ptr.size() > 1)

return ExitCode::kInvalidCommandLineArgument;

return ExitCode::kNoFailure;

std::vector<std::string>* exec_args,

std::vector<std::string>* errors,

OptionEnvvarSettings settings) {

return static_cast<int>(

ProcessGlobalArgsInternal(args, exec_args, errors, settings));

std::vector<std::string>* argv,

std::vector<std::string>* exec_argv,

std::vector<std::string>* errors,

ProcessInitializationFlags::Flags flags) {

// Make sure InitializeNodeWithArgsInternal() is called only once.

CHECK(!init_called.exchange(true));

// Initialize node_start_time to get relative uptime.

per_process::node_start_time = uv_hrtime();

// Register built-in bindings

binding::RegisterBuiltinBindings();

// Make inherited handles noninheritable.

if (!(flags & ProcessInitializationFlags::kEnableStdioInheritance) &&

!(flags & ProcessInitializationFlags::kNoStdioInitialization)) {

uv_disable_stdio_inheritance();

}

// Cache the original command line to be

// used in diagnostic reports.

per_process::cli_options->cmdline = *argv;

// Node provides a "v8.setFlagsFromString" method to dynamically change flags.

// Hence do not freeze flags when initializing V8. In a browser setting, this

// is security relevant, for Node it's less important.

V8::SetFlagsFromString("--no-freeze-flags-after-init");

#if defined(NODE_V8_OPTIONS)

// Should come before the call to V8::SetFlagsFromCommandLine()

// so the user can disable a flag --foo at run-time by passing

// --no_foo from the command line.

V8::SetFlagsFromString(NODE_V8_OPTIONS, sizeof(NODE_V8_OPTIONS) - 1);

#endif

if (!!(flags & ProcessInitializationFlags::kGeneratePredictableSnapshot) ||

per_process::cli_options->per_isolate->build_snapshot) {

v8::V8::SetFlagsFromString("--predictable");

v8::V8::SetFlagsFromString("--random_seed=42");

}

// Specify this explicitly to avoid being affected by V8 changes to the

// default value.

V8::SetFlagsFromString("--rehash-snapshot");

HandleEnvOptions(per_process::cli_options->per_isolate->per_env);

std::string node_options;

std::string node_options_from_dotenv;

auto env_files = node::Dotenv::GetDataFromArgs(*argv);

if (!env_files.empty()) {

CHECK(!per_process::v8_initialized);

for (const auto& file_data : env_files) {

switch (per_process::dotenv_file.ParsePath(file_data.path)) {

case Dotenv::ParseResult::Valid:

break;

case Dotenv::ParseResult::InvalidContent:

errors->push_back(file_data.path + ": invalid format");

break;

case Dotenv::ParseResult::FileError:

if (file_data.is_optional) {

fprintf(stderr,

"%s not found. Continuing without it.\n",

file_data.path.c_str());

continue;

}

errors->push_back(file_data.path + ": not found");

break;

default:

UNREACHABLE();

}

}

per_process::dotenv_file.AssignNodeOptionsIfAvailable(

&node_options_from_dotenv);

}

std::string node_options_from_config;

auto config_path = per_process::config_reader.GetDataFromArgs(argv);

if (per_process::config_reader.HasInvalidDefaultConfigFileArgument()) {

errors->push_back("--experimental-default-config-file does not take an "

"argument");

return ExitCode::kInvalidCommandLineArgument;

}

if (config_path) {

switch (per_process::config_reader.ParseConfig(*config_path)) {

case ParseResult::Valid:

break;

case ParseResult::InvalidContent:

errors->push_back(std::string(*config_path) + ": invalid content");

break;

case ParseResult::FileError:

errors->push_back(std::string(*config_path) + ": not found");

break;

default:

UNREACHABLE();

}

node_options_from_config = per_process::config_reader.GetNodeOptions();

// (@marco-ippolito) Avoid reparsing the env options again

std::vector<std::string> env_argv_from_config =

ParseNodeOptionsEnvVar(node_options_from_config, errors);

// Check the number of flags in NODE_OPTIONS from the config file

// matches the parsed ones. This avoid users from sneaking in

// additional flags.

if (env_argv_from_config.size() !=

per_process::config_reader.GetFlagsSize()) {

errors->emplace_back("The number of NODE_OPTIONS doesn't match "

"the number of flags in the config file");

}

}

node_options = node_options_from_config + node_options_from_dotenv;

#if !defined(NODE_WITHOUT_NODE_OPTIONS)

bool should_parse_node_options =

!(flags & ProcessInitializationFlags::kDisableNodeOptionsEnv);

#ifndef DISABLE_SINGLE_EXECUTABLE_APPLICATION

if (sea::IsSingleExecutable()) {

sea::SeaResource sea_resource = sea::FindSingleExecutableResource();

if (sea_resource.exec_argv_extension != sea::SeaExecArgvExtension::kEnv) {

should_parse_node_options = false;

}

}

#endif

if (should_parse_node_options) {

// NODE_OPTIONS environment variable is preferred over the file one.

if (credentials::SafeGetenv("NODE_OPTIONS", &node_options) ||

!node_options.empty()) {

std::vector<std::string> env_argv =

ParseNodeOptionsEnvVar(node_options, errors);

if (!errors->empty()) return ExitCode::kInvalidCommandLineArgument;

// [0] is expected to be the program name, fill it in from the real argv.

env_argv.insert(env_argv.begin(), argv->at(0));

const ExitCode exit_code = ProcessGlobalArgsInternal(

&env_argv, nullptr, errors, kAllowedInEnvvar);

if (exit_code != ExitCode::kNoFailure) return exit_code;

}

} else {

std::string node_repl_external_env = {};

if (credentials::SafeGetenv("NODE_REPL_EXTERNAL_MODULE",

&node_repl_external_env) ||

!node_repl_external_env.empty()) {

errors->emplace_back("NODE_REPL_EXTERNAL_MODULE can't be used with "

"kDisableNodeOptionsEnv");

return ExitCode::kInvalidCommandLineArgument;

}

}

#endif

if (!(flags & ProcessInitializationFlags::kDisableCLIOptions)) {

// Parse the options coming from the config file.

// This is done before parsing the command line options

// as the cli flags are expected to override the config file ones.

std::vector<std::string> extra_argv =

per_process::config_reader.GetNamespaceFlags();

// [0] is expected to be the program name, fill it in from the real argv.

extra_argv.insert(extra_argv.begin(), argv->at(0));

// Parse the extra argv coming from the config file

ExitCode exit_code = ProcessGlobalArgsInternal(

&extra_argv, nullptr, errors, kDisallowedInEnvvar);