src/node_errors: add re-entrancy guard to prevent infinite recursion in TriggerUncaughtException

Add a thread_local re-entrancy guard to TriggerUncaughtException()
that detects when the JS-level exception handler (process._fatalException)
itself triggers another exception through the inspector protocol.

This prevents the infinite loop:
  TriggerUncaughtException -> InspectorConsoleCall ->
  TriggerUncaughtException -> InspectorConsoleCall -> ...

When re-entrancy is detected, the function prints a diagnostic to
stderr, reports the fatal exception with kDontEnhance (to bypass the
inspector path), and aborts the process.

Fixes: #64326

Author: themuuln

src/node_errors.cc

@@ -191,6 +191,7 @@ static std::string GetErrorSource(Isolate* isolate,
 
 static std::atomic<bool> is_in_oom{false};
 static thread_local std::atomic<bool> is_retrieving_js_stacktrace{false};
+static thread_local bool is_in_uncaught_exception = false;
 MaybeLocal<StackTrace> GetCurrentStackTrace(Isolate* isolate, int frame_count) {
   if (isolate == nullptr) {
     return MaybeLocal<StackTrace>();
@@ -1278,6 +1279,36 @@ void TriggerUncaughtException(Isolate* isolate,
   CHECK(isolate->InContext());
   Local<Context> context = isolate->GetCurrentContext();
   Environment* env = Environment::GetCurrent(context);
+  // Re-entrancy guard: prevent infinite recursion when the JS-level
+  // exception handler (process._fatalException) itself triggers another
+  // exception through the inspector protocol, causing V8's pending message
+  // reporting to call TriggerUncaughtException reentrantly.
+  if (is_in_uncaught_exception) {
+    if (env != nullptr) {
+      PrintToStderrAndFlush(
+          "FATAL ERROR: Re-entrant uncaught exception detected.\n"
+          "The exception handler threw an error while processing a\n"
+          "previous uncaught exception, likely due to an inspector\n"
+          "protocol issue. Aborting to prevent infinite recursion.");
+      // Use kDontEnhance to avoid the inspector reporting path that may
+      // have caused the re-entrancy.
+      ReportFatalException(env,
+                           error,
+                           message,
+                           EnhanceFatalException::kDontEnhance);
+    } else {
+      PrintToStderrAndFlush(
+          "FATAL ERROR: Re-entrant uncaught exception (no environment).");
+    }
+    ABORT();
+  }
+  // RAII guard to ensure the flag is cleared when TriggerUncaughtException
+  // returns normally. Note: ABORT() and env->Exit() do not run this
+  // destructor, which is intentional — the process is terminating.
+  struct UncaughtExceptionGuard {
+    UncaughtExceptionGuard() { is_in_uncaught_exception = true; }
+    ~UncaughtExceptionGuard() { is_in_uncaught_exception = false; }
+  } uncaught_exception_guard;
   if (env == nullptr) {
     // This means that the exception happens before Environment is assigned
     // to the context e.g. when there is a SyntaxError in a per-context