watch: strip watch flags from NODE_OPTIONS in child process

Signed-off-by: marcopiraccini <[email protected]>

Author: marcopiraccini

lib/internal/main/watch_mode.js

@@ -7,7 +7,7 @@ const {
   ArrayPrototypePush,
   ArrayPrototypePushApply,
   ArrayPrototypeSlice,
-  RegExpPrototypeSymbolSplit,
+  StringPrototypeIncludes,
   StringPrototypeStartsWith,
 } = primordials;
 
@@ -19,7 +19,7 @@ const {
   triggerUncaughtException,
   exitCodes: { kNoFailure },
 } = internalBinding('errors');
-const { getOptionValue } = require('internal/options');
+const { getOptionValue, parseNodeOptionsEnvVar } = require('internal/options');
 const { FilesWatcher } = require('internal/watch_mode/files_watcher');
 const { green, blue, red, white, clear } = require('internal/util/colors');
 const { convertToValidSignal } = require('internal/util');
@@ -85,14 +85,15 @@ for (let i = 0; i < process.execArgv.length; i++) {
 
 ArrayPrototypePushApply(argsWithoutWatchOptions, kCommand);
 
+// Strip watch-related flags from NODE_OPTIONS to prevent infinite loop
+// when NODE_OPTIONS contains --watch (see issue #61740).
 const kNodeOptions = process.env.NODE_OPTIONS;
 let cleanNodeOptions = kNodeOptions;
 if (kNodeOptions != null) {
-  const nodeOptionsArgs = [];
-  const parts = RegExpPrototypeSymbolSplit(/\s+/, kNodeOptions);
+  const keep = [];
+  const parts = parseNodeOptionsEnvVar(kNodeOptions);
   for (let i = 0; i < parts.length; i++) {
     const part = parts[i];
-    if (part === '') continue;
     if (part === '--watch' ||
         part === '--watch-preserve-output' ||
         StringPrototypeStartsWith(part, '--watch=') ||
@@ -102,13 +103,17 @@ if (kNodeOptions != null) {
       continue;
     }
     if (part === '--watch-path' || part === '--watch-kill-signal') {
-      // These flags take a separate value argument
+      // Skip the flag and its separate value argument
       i++;
       continue;
     }
-    ArrayPrototypePush(nodeOptionsArgs, part);
+    // The C++ tokenizer strips quotes during parsing, so values that
+    // originally contained spaces (e.g. --require "./path with spaces/f.js")
+    // need to be re-quoted before rejoining into a single string, otherwise
+    // the child's C++ parser would split them into separate tokens.
+    ArrayPrototypePush(keep, StringPrototypeIncludes(part, ' ') ? `"${part}"` : part);
   }
-  cleanNodeOptions = ArrayPrototypeJoin(nodeOptionsArgs, ' ');
+  cleanNodeOptions = ArrayPrototypeJoin(keep, ' ');
 }
 
 const watcher = new FilesWatcher({ debounce: 200, mode: kShouldFilterModules ? 'filter' : 'all' });

lib/internal/options.js

@@ -16,6 +16,7 @@ const {
   getEmbedderOptions: getEmbedderOptionsFromBinding,
   getEnvOptionsInputType,
   getNamespaceOptionsInputType,
+  parseNodeOptionsEnvVar,
 } = internalBinding('options');
 
 let warnOnAllowUnauthorized = true;
@@ -172,5 +173,6 @@ module.exports = {
   getAllowUnauthorized,
   getEmbedderOptions,
   generateConfigJsonSchema,
+  parseNodeOptionsEnvVar,
   refreshOptions,
 };

src/node_options.cc

@@ -2096,6 +2096,29 @@ void GetOptionsAsFlags(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(result);
 }
 
+void ParseNodeOptionsEnvVarBinding(
+    const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = args.GetIsolate();
+  Local<Context> context = isolate->GetCurrentContext();
+
+  Utf8Value node_options(isolate, args[0]);
+  std::string options_str(*node_options, node_options.length());
+
+  std::vector<std::string> errors;
+  std::vector<std::string> result =
+      ParseNodeOptionsEnvVar(options_str, &errors);
+
+  if (!errors.empty()) {
+    Environment* env = Environment::GetCurrent(context);
+    env->ThrowError(errors[0].c_str());
+    return;
+  }
+
+  Local<Value> v8_result;
+  CHECK(ToV8Value(context, result).ToLocal(&v8_result));
+  args.GetReturnValue().Set(v8_result);
+}
+
 void Initialize(Local<Object> target,
                 Local<Value> unused,
                 Local<Context> context,
@@ -2116,6 +2139,10 @@ void Initialize(Local<Object> target,
                         target,
                         "getNamespaceOptionsInputType",
                         GetNamespaceOptionsInputType);
+  SetMethodNoSideEffect(context,
+                        target,
+                        "parseNodeOptionsEnvVar",
+                        ParseNodeOptionsEnvVarBinding);
   Local<Object> env_settings = Object::New(isolate);
   NODE_DEFINE_CONSTANT(env_settings, kAllowedInEnvvar);
   NODE_DEFINE_CONSTANT(env_settings, kDisallowedInEnvvar);
@@ -2144,6 +2171,7 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(GetEmbedderOptions);
   registry->Register(GetEnvOptionsInputType);
   registry->Register(GetNamespaceOptionsInputType);
+  registry->Register(ParseNodeOptionsEnvVarBinding);
 }
 }  // namespace options_parser