inspector: fix connectToMainThread() abort without parent inspector

`inspector.Session#connectToMainThread()` in a Worker aborted the
process on `CHECK_NOT_NULL(parent_handle_)` in
`Agent::ConnectToMainThread()` when the parent Environment was created
with `kNoCreateInspector`, as embedders that run their own inspector
(or none) do.

Throw the new `ERR_INSPECTOR_NOT_AVAILABLE` in that case, next to the
existing throw for a Worker whose own inspector is not initialized.

Refs: #35025
Signed-off-by: Shelley Vohr <shelley.vohr@gmail.com>
PR-URL: #65976
Reviewed-By: Kohei Ueno <kohei.ueno119@gmail.com>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: codebytere

src/inspector_agent.cc

@@ -975,8 +975,12 @@ std::unique_ptr<InspectorSession> Agent::ConnectToMainThread(
     ThrowUninitializedInspectorError(parent_env_);
     return std::unique_ptr<InspectorSession>{};
   }
+  if (!parent_handle_) {
+    THROW_ERR_INSPECTOR_NOT_AVAILABLE(
+        parent_env_, "The parent thread's inspector is not available");
+    return std::unique_ptr<InspectorSession>{};
+  }
 
-  CHECK_NOT_NULL(parent_handle_);
   CHECK_NOT_NULL(client_);
   auto thread_safe_delegate =
       client_->getThreadHandle()->MakeDelegateThreadSafe(std::move(delegate));

src/node_errors.h

@@ -96,6 +96,7 @@ void OOMErrorHandler(const char* location, const v8::OOMDetails& details);
   V(ERR_HEAP_PROFILE_HAVE_BEEN_STARTED, Error)                                 \
   V(ERR_HEAP_PROFILE_NOT_STARTED, Error)                                       \
   V(ERR_ILLEGAL_CONSTRUCTOR, Error)                                            \
+  V(ERR_INSPECTOR_NOT_AVAILABLE, Error)                                        \
   V(ERR_INVALID_ADDRESS, Error)                                                \
   V(ERR_INVALID_ARG_VALUE, TypeError)                                          \
   V(ERR_OSSL_EVP_INVALID_DIGEST, Error)                                        \

test/cctest/test_environment.cc

@@ -434,6 +434,27 @@ TEST_F(EnvironmentTest, SharedIsolateDataLoadsBindingsTwice) {
   EXPECT_EQ(node::SpinEventLoop(*env2).FromJust(), 0);
 }
 
+#if HAVE_INSPECTOR
+TEST_F(EnvironmentTest, WorkerConnectToMainThreadWithoutInspector) {
+  const v8::HandleScope handle_scope(isolate_);
+  const Argv argv;
+  Env env{handle_scope, argv, node::EnvironmentFlags::kNoCreateInspector};
+  node::LoadEnvironment(
+      *env,
+      "const { Worker } = require('worker_threads');"
+      "const w = new Worker(`"
+      "  const { Session } = require('inspector');"
+      "  try { new Session().connectToMainThread(); }"
+      "  catch (e) { process.exit(e.code === 'ERR_INSPECTOR_NOT_AVAILABLE' ?"
+      "    0 : 2); }"
+      "  process.exit(3);"
+      "`, { eval: true });"
+      "w.on('exit', (code) => { process.exitCode = code; });")
+      .ToLocalChecked();
+  EXPECT_EQ(node::SpinEventLoop(*env).FromJust(), 0);
+}
+#endif  // HAVE_INSPECTOR
+
 TEST_F(EnvironmentTest, NoEnvironmentSanity) {
   const v8::HandleScope handle_scope(isolate_);
   v8::Local<v8::Context> context = v8::Context::New(isolate_);