From 525a2d22440744184220b2a5f43a0bffb9a03fc4 Mon Sep 17 00:00:00 2001
From: islandryu <shimaryuhei@gmail.com>
Date: Sat, 25 Jan 2025 17:26:31 +0900
Subject: [PATCH 1/7] inspector: support for worker inspection in chrome
 devtools

Fixes: https://github.com/nodejs/node/issues/56343
---
 doc/api/cli.md                                | 12 +++
 src/inspector/main_thread_interface.h         |  8 ++
 src/inspector/node_inspector.gypi             |  5 +
 src/inspector/node_protocol.pdl               | 22 +++++
 src/inspector/target_agent.cc                 | 96 +++++++++++++++++++
 src/inspector/target_agent.h                  | 49 ++++++++++
 src/inspector_agent.cc                        | 56 ++++++++---
 src/inspector_io.cc                           | 61 ++++++++++--
 src/node_options.cc                           |  3 +
 src/node_options.h                            |  1 +
 test/parallel/test-inspector-worker-target.js | 32 +++++++
 11 files changed, 322 insertions(+), 23 deletions(-)
 create mode 100644 src/inspector/target_agent.cc
 create mode 100644 src/inspector/target_agent.h
 create mode 100644 test/parallel/test-inspector-worker-target.js

diff --git a/doc/api/cli.md b/doc/api/cli.md
index ececfcefb687c7..b24381e6d48bc7 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -1136,6 +1136,18 @@ added: v22.4.0
 
 Enable experimental [`Web Storage`][] support.
 
+### `--experimental-worker-inspection`
+
+<!-- YAML
+added:
+  - v22.14.0
+  - v20.19.0
+-->
+
+> Stability: 1 - Experimental
+
+Enable experimental support for the worker inspection with Chrome DevTools.
+
 ### `--expose-gc`
 
 <!-- YAML
diff --git a/src/inspector/main_thread_interface.h b/src/inspector/main_thread_interface.h
index 35997adbe5ac66..975821773d197f 100644
--- a/src/inspector/main_thread_interface.h
+++ b/src/inspector/main_thread_interface.h
@@ -57,6 +57,13 @@ class MainThreadHandle : public std::enable_shared_from_this<MainThreadHandle> {
   std::unique_ptr<InspectorSessionDelegate> MakeDelegateThreadSafe(
       std::unique_ptr<InspectorSessionDelegate> delegate);
   bool Expired();
+  void SetTargetSessionId(int target_session_id) {
+    target_session_id_ = target_session_id;
+  }
+  std::optional<int> GetTargetSessionId() {
+    return target_session_id_;
+  }
+
 
  private:
   void Reset();
@@ -65,6 +72,7 @@ class MainThreadHandle : public std::enable_shared_from_this<MainThreadHandle> {
   Mutex block_lock_;
   int next_session_id_ = 0;
   std::atomic_int next_object_id_ = {1};
+  std::optional<int> target_session_id_ = std::nullopt;
 
   friend class MainThreadInterface;
 };
diff --git a/src/inspector/node_inspector.gypi b/src/inspector/node_inspector.gypi
index 3ae714b51407a4..d85248513a9194 100644
--- a/src/inspector/node_inspector.gypi
+++ b/src/inspector/node_inspector.gypi
@@ -30,6 +30,9 @@
       'src/inspector/network_inspector.h',
       'src/inspector/network_agent.cc',
       'src/inspector/network_agent.h',
+      'src/inspector/network_agent.h',
+      'src/inspector/target_agent.cc',
+      'src/inspector/target_agent.h',
       'src/inspector/worker_inspector.cc',
       'src/inspector/worker_inspector.h',
     ],
@@ -45,6 +48,8 @@
       '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/NodeRuntime.h',
       '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/Network.cpp',
       '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/Network.h',
+      '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/Target.cpp',
+      '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/Target.h',
     ],
     'node_protocol_files': [
       '<(protocol_tool_path)/lib/Forward_h.template',
diff --git a/src/inspector/node_protocol.pdl b/src/inspector/node_protocol.pdl
index d5b50dc81b40f1..74de9b52eba887 100644
--- a/src/inspector/node_protocol.pdl
+++ b/src/inspector/node_protocol.pdl
@@ -220,3 +220,25 @@ experimental domain NodeRuntime
   # This event is fired when the runtime is waiting for the debugger. For
   # example, when inspector.waitingForDebugger is called
   event waitingForDebugger
+
+# https://chromedevtools.github.io/devtools-protocol/1-3/Target/
+experimental domain Target
+  type SessionID extends string
+  type TargetID extends string
+  type TargetInfo extends object
+    properties
+      TargetID targetId
+      string type
+      string title
+      string url
+      boolean attached
+      boolean canAccessOpener
+  event targetCreated
+    parameters
+      TargetInfo targetInfo
+  event attachedToTarget
+    parameters
+      SessionID sessionId
+      TargetInfo targetInfo
+      boolean waitingForDebugger
+      
\ No newline at end of file
diff --git a/src/inspector/target_agent.cc b/src/inspector/target_agent.cc
new file mode 100644
index 00000000000000..e56fd7bdf4c2ff
--- /dev/null
+++ b/src/inspector/target_agent.cc
@@ -0,0 +1,96 @@
+#include "target_agent.h"
+#include <iostream>
+#include <memory>
+#include <set>
+#include <string>
+#include <tuple>
+#include <utility>
+#include "inspector/node_string.h"
+#include "inspector/worker_inspector.h"
+#include "main_thread_interface.h"
+
+namespace node {
+namespace inspector {
+namespace protocol {
+
+std::unordered_map<int,std::shared_ptr<MainThreadHandle>> TargetAgent::target_session_id_worker_map_ = std::unordered_map<int, std::shared_ptr<MainThreadHandle>>();
+
+
+class WorkerTargetDelegate : public WorkerDelegate {
+ public:
+  explicit WorkerTargetDelegate(std::shared_ptr<TargetAgent> target_agent)
+      : target_agent_(target_agent) {}
+
+
+  void WorkerCreated(const std::string& title,
+                     const std::string& url,
+                     bool waiting,
+                     std::shared_ptr<MainThreadHandle> worker) override {
+    std::string target_id = std::to_string(target_agent_->getNextTargetId());
+    std::string type = "worker";
+    
+    target_agent_->targetCreated(target_id, type, title, url);
+    target_agent_->attachedToTarget(worker,target_id, type, title, url);
+  }
+
+ private:
+  const std::shared_ptr<TargetAgent> target_agent_;
+};
+
+std::unique_ptr<Target::TargetInfo> createTargetInfo(
+    const String& target_id,
+    const String& type,
+    const String& title,
+    const String& url) {
+  return Target::TargetInfo::create()
+      .setTargetId(target_id)
+      .setType(type)
+      .setTitle(title)
+      .setUrl(url)
+      .setAttached(false)
+      .setCanAccessOpener(true)
+      .build();
+}
+
+void TargetAgent::Wire(UberDispatcher* dispatcher) {
+  frontend_ = std::make_unique<Target::Frontend>(dispatcher->channel());
+  Target::Dispatcher::wire(dispatcher, this);
+}
+
+void TargetAgent::listenWorker(std::weak_ptr<WorkerManager> worker_manager) {
+  auto manager = worker_manager.lock();
+  if (!manager) {
+    return;
+  }
+  std::unique_ptr<WorkerDelegate> delegate(new WorkerTargetDelegate(shared_from_this()));
+  worker_event_handle_ = manager->SetAutoAttach(std::move(delegate));
+}
+
+void TargetAgent::reset() {
+  if (worker_event_handle_) {
+    worker_event_handle_.reset();
+  }
+}
+
+void TargetAgent::targetCreated(const std::string &target_id,const std::string &type,const std::string &title,const std::string &url) {
+  frontend_->targetCreated(createTargetInfo(target_id, type, title, url));
+}
+
+int TargetAgent::getNextSessionId() {
+  return next_session_id_++;
+}
+
+int TargetAgent::getNextTargetId() {
+  return next_target_id_++;
+}
+
+void TargetAgent::attachedToTarget(std::shared_ptr<MainThreadHandle> worker,const std::string &target_id, const std::string &type,const  std::string &title,const  std::string &url) {
+  int session_id = getNextSessionId();
+  target_session_id_worker_map_[session_id] = worker;
+  worker->SetTargetSessionId(session_id);
+  frontend_->attachedToTarget(std::to_string(session_id), createTargetInfo(target_id, type, title, url), true);
+}
+
+} // namespace protocol
+}  // namespace inspector
+}  // namespace node
\ No newline at end of file
diff --git a/src/inspector/target_agent.h b/src/inspector/target_agent.h
new file mode 100644
index 00000000000000..8ea3c41f73adc8
--- /dev/null
+++ b/src/inspector/target_agent.h
@@ -0,0 +1,49 @@
+#ifndef SRC_INSPECTOR_TARGET_AGENT_H_
+#define SRC_INSPECTOR_TARGET_AGENT_H_
+
+#include "inspector/worker_inspector.h"
+#include "node/inspector/protocol/Target.h"
+
+#include <memory>
+#include <string>
+#include <thread>
+#include <unordered_map>
+
+namespace node {
+
+namespace inspector {
+class TargetInspector;
+
+namespace protocol {
+
+class TargetAgent : public Target::Backend, public std::enable_shared_from_this<TargetAgent> 
+{
+ public:
+  explicit TargetAgent() {}
+
+  void Wire(UberDispatcher* dispatcher);
+
+
+  void targetCreated(const std::string &target_id, const std::string &type,const  std::string &title,const  std::string &url);
+  void attachedToTarget(std::shared_ptr<MainThreadHandle> worker,const std::string &target_id, const std::string &type,const  std::string &title,const  std::string &url);
+
+  int getNextTargetId();
+
+  void listenWorker(std::weak_ptr<WorkerManager> worker_manager);
+  void reset();
+  static std::unordered_map<int,std::shared_ptr<MainThreadHandle>> target_session_id_worker_map_;
+ private:
+  int getNextSessionId();
+  std::shared_ptr<Target::Frontend> frontend_;
+  std::weak_ptr<WorkerManager> worker_manager_;
+  int next_session_id_ = 1;
+  int next_target_id_ = 1;
+  std::unique_ptr<WorkerManagerEventHandle> worker_event_handle_ = nullptr;
+};
+
+}  // namespace protocol
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_TARGET_AGENT_H_
+
diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc
index be767c1825d64f..47f2e19f82f5b1 100644
--- a/src/inspector_agent.cc
+++ b/src/inspector_agent.cc
@@ -1,4 +1,5 @@
 #include "inspector_agent.h"
+#include <string>
 
 #include "crdtp/json.h"
 #include "env-inl.h"
@@ -7,6 +8,7 @@
 #include "inspector/node_json.h"
 #include "inspector/node_string.h"
 #include "inspector/runtime_agent.h"
+#include "inspector/target_agent.h"
 #include "inspector/tracing_agent.h"
 #include "inspector/worker_agent.h"
 #include "inspector/worker_inspector.h"
@@ -20,6 +22,7 @@
 #include "permission/permission.h"
 #include "timer_wrap-inl.h"
 #include "util-inl.h"
+#include "util.h"
 #include "v8-inspector.h"
 #include "v8-platform.h"
 
@@ -223,8 +226,9 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
                        std::unique_ptr<InspectorSessionDelegate> delegate,
                        std::shared_ptr<MainThreadHandle> main_thread_,
                        bool prevent_shutdown)
-      : delegate_(std::move(delegate)), prevent_shutdown_(prevent_shutdown),
-        retaining_context_(false) {
+      : delegate_(std::move(delegate)), main_thread_(main_thread_),
+        prevent_shutdown_(prevent_shutdown), retaining_context_(false)
+         {
     session_ = inspector->connect(CONTEXT_GROUP_ID,
                                   this,
                                   StringView(),
@@ -241,6 +245,11 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
     runtime_agent_->Wire(node_dispatcher_.get());
     network_inspector_ = std::make_unique<NetworkInspector>(env);
     network_inspector_->Wire(node_dispatcher_.get());
+    if(env->options()->experimental_worker_inspection) {
+      target_agent_ = std::make_shared<protocol::TargetAgent>();
+      target_agent_->Wire(node_dispatcher_.get());
+      target_agent_->listenWorker(worker_manager);
+    }
   }
 
   ~ChannelImpl() override {
@@ -254,6 +263,9 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
     runtime_agent_.reset();  // Dispose before the dispatchers
     network_inspector_->Disable();
     network_inspector_.reset();  // Dispose before the dispatchers
+    if(target_agent_) {
+      target_agent_->reset();
+    }
   }
 
   void emitNotificationFromBackend(const StringView& event,
@@ -337,6 +349,16 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
   // crdtp::FrontendChannel
   void FlushProtocolNotifications() override {}
 
+  std::string serializeToJSON(
+    std::unique_ptr<Serializable> message) {
+    std::vector<uint8_t> cbor = message->Serialize();
+    std::string json;
+    crdtp::Status status = ConvertCBORToJSON(crdtp::SpanFrom(cbor), &json);
+    DCHECK(status.ok());
+    USE(status);
+    return json;
+  }
+
   void sendMessageToFrontend(const StringView& message) {
     if (per_process::enabled_debug_list.enabled(
             DebugCategory::INSPECTOR_SERVER)) {
@@ -345,6 +367,18 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
                          "[inspector send] %s\n",
                          raw_message);
     }
+    std::optional<int> target_session_id = main_thread_->GetTargetSessionId();
+    if (target_session_id.has_value()) {
+      std::unique_ptr<protocol::DictionaryValue> value =
+          protocol::DictionaryValue::cast(
+              JsonUtil::parseJSON(message));
+      std::string target_session_id_str = std::to_string(*target_session_id);
+      value->setString("sessionId", target_session_id_str);
+      std::string json = serializeToJSON(std::move(value));
+
+      delegate_->SendMessageToFrontend(Utf8ToStringView(json)->string());
+    }
+
     delegate_->SendMessageToFrontend(message);
   }
 
@@ -355,24 +389,14 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
   // crdtp::FrontendChannel
   void SendProtocolResponse(int callId,
                             std::unique_ptr<Serializable> message) override {
-    std::vector<uint8_t> cbor = message->Serialize();
-    std::string json;
-    crdtp::Status status = ConvertCBORToJSON(crdtp::SpanFrom(cbor), &json);
-    DCHECK(status.ok());
-    USE(status);
-
+    std::string json = serializeToJSON(std::move(message));
     sendMessageToFrontend(json);
   }
 
   // crdtp::FrontendChannel
   void SendProtocolNotification(
       std::unique_ptr<Serializable> message) override {
-    std::vector<uint8_t> cbor = message->Serialize();
-    std::string json;
-    crdtp::Status status = ConvertCBORToJSON(crdtp::SpanFrom(cbor), &json);
-    DCHECK(status.ok());
-    USE(status);
-
+    std::string json = serializeToJSON(std::move(message));
     sendMessageToFrontend(json);
   }
 
@@ -386,10 +410,12 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
   std::unique_ptr<protocol::RuntimeAgent> runtime_agent_;
   std::unique_ptr<protocol::TracingAgent> tracing_agent_;
   std::unique_ptr<protocol::WorkerAgent> worker_agent_;
+  std::shared_ptr<protocol::TargetAgent> target_agent_;
   std::unique_ptr<NetworkInspector> network_inspector_;
   std::unique_ptr<InspectorSessionDelegate> delegate_;
   std::unique_ptr<v8_inspector::V8InspectorSession> session_;
-  std::unique_ptr<UberDispatcher> node_dispatcher_;
+  std::unique_ptr<protocol::UberDispatcher> node_dispatcher_;
+  std::shared_ptr<MainThreadHandle> main_thread_;
   bool prevent_shutdown_;
   bool retaining_context_;
 };
diff --git a/src/inspector_io.cc b/src/inspector_io.cc
index 4e76e529fcf341..c28602b0ca0d3c 100644
--- a/src/inspector_io.cc
+++ b/src/inspector_io.cc
@@ -4,6 +4,7 @@
 #include "crypto/crypto_util.h"
 #include "debug_utils-inl.h"
 #include "inspector/main_thread_interface.h"
+#include "inspector/node_json.h"
 #include "inspector/node_string.h"
 #include "inspector_socket_server.h"
 #include "ncrypto.h"
@@ -13,6 +14,7 @@
 #include "util-inl.h"
 #include "v8-inspector.h"
 #include "zlib.h"
+#include "inspector/target_agent.h"
 
 #include <deque>
 #include <cstring>
@@ -218,6 +220,7 @@ class InspectorIoDelegate: public node::inspector::SocketServerDelegate {
   void StartSession(int session_id, const std::string& target_id) override;
   void MessageReceived(int session_id, const std::string& message) override;
   void EndSession(int session_id) override;
+  std::optional<std::string> GetTargetSessionId(const std::string& message);
 
   std::vector<std::string> GetTargetIds() override;
   std::string GetTargetTitle(const std::string& id) override;
@@ -337,20 +340,62 @@ InspectorIoDelegate::InspectorIoDelegate(
 
 void InspectorIoDelegate::StartSession(int session_id,
                                        const std::string& target_id) {
-  auto session = main_thread_->Connect(
-      std::unique_ptr<InspectorSessionDelegate>(
-          new IoSessionDelegate(request_queue_->handle(), session_id)), true);
-  if (session) {
-    sessions_[session_id] = std::move(session);
-    fprintf(stderr, "Debugger attached.\n");
+  fprintf(stderr, "Debugger attached.\n");
+}
+
+std::optional<std::string> InspectorIoDelegate::GetTargetSessionId(const std::string& message) {
+  const std::string_view view(message.data(), message.size());
+  std::unique_ptr<protocol::DictionaryValue> value =
+      protocol::DictionaryValue::cast(
+          JsonUtil::parseJSON(view));
+  protocol::String target_session_id;
+  protocol::Value* target_session_id_value = value->get("sessionId");
+  if (target_session_id_value) {
+    target_session_id_value->asString(&target_session_id);
+  }
+
+  if (!target_session_id.empty()) {
+    return target_session_id;
   }
+  return std::nullopt;
 }
 
 void InspectorIoDelegate::MessageReceived(int session_id,
                                           const std::string& message) {
-  auto session = sessions_.find(session_id);
-  if (session != sessions_.end())
+  std::optional<std::string> target_session_id_str = GetTargetSessionId(message);
+  std::shared_ptr<MainThreadHandle> worker = nullptr;
+  int merged_session_id = session_id;
+  if(!target_session_id_str->empty()) {
+    int target_session_id = std::stoi(*target_session_id_str);
+    worker = protocol::TargetAgent::target_session_id_worker_map_[target_session_id];
+    if(worker) {
+      merged_session_id += target_session_id << 16;
+    }
+  }
+
+  auto session = sessions_.find(merged_session_id);
+
+  if(session == sessions_.end()) {
+    std::unique_ptr<InspectorSession> session;
+    if(worker) {
+      session = worker->Connect(
+        std::unique_ptr<InspectorSessionDelegate>(
+            new IoSessionDelegate(request_queue_->handle(), session_id)), true);
+    } else {
+      session = main_thread_->Connect(
+        std::unique_ptr<InspectorSessionDelegate>(
+            new IoSessionDelegate(request_queue_->handle(), session_id)), true);
+    }
+
+    if (session) {
+      sessions_[merged_session_id] = std::move(session);
+      sessions_[merged_session_id]->Dispatch(Utf8ToStringView(message)->string());
+    } else {
+      fprintf(stderr, "Failed to connect to inspector session.\n");
+    }
+  } else {
     session->second->Dispatch(Utf8ToStringView(message)->string());
+  }
 }
 
 void InspectorIoDelegate::EndSession(int session_id) {
diff --git a/src/node_options.cc b/src/node_options.cc
index f96f9d2de9718e..8e77ef1aed3c04 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -630,6 +630,9 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
   AddOption("--experimental-network-inspection",
             "experimental network inspection support",
             &EnvironmentOptions::experimental_network_inspection);
+  AddOption("--experimental-worker-inspection",
+            "experimental worker inspection support",
+            &EnvironmentOptions::experimental_worker_inspection);
   AddOption(
       "--heap-prof",
       "Start the V8 heap profiler on start up, and write the heap profile "
diff --git a/src/node_options.h b/src/node_options.h
index 3c4d2f853f2b35..665212f6b3a6cc 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -171,6 +171,7 @@ class EnvironmentOptions : public Options {
   std::string cpu_prof_name;
   bool cpu_prof = false;
   bool experimental_network_inspection = false;
+  bool experimental_worker_inspection = false;
   std::string heap_prof_dir;
   std::string heap_prof_name;
   static const uint64_t kDefaultHeapProfInterval = 512 * 1024;
diff --git a/test/parallel/test-inspector-worker-target.js b/test/parallel/test-inspector-worker-target.js
new file mode 100644
index 00000000000000..d361c01d2f13e8
--- /dev/null
+++ b/test/parallel/test-inspector-worker-target.js
@@ -0,0 +1,32 @@
+// Flags: --experimental-worker-inspection
+'use strict';
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const { Worker } = require('worker_threads');
+
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const { Session } = require('inspector');
+
+const session = new Session();
+
+async function test() {
+  session.connect();
+  
+  new Worker(fixtures.path("worker-script.mjs"), { type: 'module' });
+  session.on("Target.targetCreated", common.mustCall(({ params }) => {
+    const targetInfo = params.targetInfo;
+    assert.strictEqual(targetInfo.type, "worker");
+    assert.ok(targetInfo.url.includes("worker-script.mjs"));
+    assert.strictEqual(targetInfo.targetId, "1");
+  }));
+
+  session.on("Target.attachedToTarget", common.mustCall(({ params }) => {
+    assert.strictEqual(params.sessionId, "1");
+  }));
+}
+
+test().then(common.mustCall());
+

From cab3f96680843ac801b8b9a097e1a5d1acae2f1d Mon Sep 17 00:00:00 2001
From: islandryu <shimaryuhei@gmail.com>
Date: Mon, 27 Jan 2025 20:35:02 +0900
Subject: [PATCH 2/7] fix/test

---
 src/inspector/target_agent.cc                 |  2 +-
 test/parallel/test-inspector-worker-target.js | 31 ++++++++-----------
 2 files changed, 14 insertions(+), 19 deletions(-)

diff --git a/src/inspector/target_agent.cc b/src/inspector/target_agent.cc
index e56fd7bdf4c2ff..50ee5b16e02489 100644
--- a/src/inspector/target_agent.cc
+++ b/src/inspector/target_agent.cc
@@ -93,4 +93,4 @@ void TargetAgent::attachedToTarget(std::shared_ptr<MainThreadHandle> worker,cons
 
 } // namespace protocol
 }  // namespace inspector
-}  // namespace node
\ No newline at end of file
+}  // namespace node
diff --git a/test/parallel/test-inspector-worker-target.js b/test/parallel/test-inspector-worker-target.js
index d361c01d2f13e8..034fc5a6aebd73 100644
--- a/test/parallel/test-inspector-worker-target.js
+++ b/test/parallel/test-inspector-worker-target.js
@@ -12,21 +12,16 @@ const { Session } = require('inspector');
 
 const session = new Session();
 
-async function test() {
-  session.connect();
-  
-  new Worker(fixtures.path("worker-script.mjs"), { type: 'module' });
-  session.on("Target.targetCreated", common.mustCall(({ params }) => {
-    const targetInfo = params.targetInfo;
-    assert.strictEqual(targetInfo.type, "worker");
-    assert.ok(targetInfo.url.includes("worker-script.mjs"));
-    assert.strictEqual(targetInfo.targetId, "1");
-  }));
-
-  session.on("Target.attachedToTarget", common.mustCall(({ params }) => {
-    assert.strictEqual(params.sessionId, "1");
-  }));
-}
-
-test().then(common.mustCall());
-
+session.connect();
+
+new Worker(fixtures.path("worker-script.mjs"), { type: 'module' });
+session.on("Target.targetCreated", common.mustCall(({ params }) => {
+  const targetInfo = params.targetInfo;
+  assert.strictEqual(targetInfo.type, "worker");
+  assert.ok(targetInfo.url.includes("worker-script.mjs"));
+  assert.strictEqual(targetInfo.targetId, "1");
+}));
+
+session.on("Target.attachedToTarget", common.mustCall(({ params }) => {
+  assert.strictEqual(params.sessionId, "1");
+}));

From fafadd054f27c60ae7c89c00871845544fe95259 Mon Sep 17 00:00:00 2001
From: islandryu <shimaryuhei@gmail.com>
Date: Wed, 29 Jan 2025 23:23:19 +0900
Subject: [PATCH 3/7] format

---
 src/inspector/node_protocol.pdl               |  1 -
 src/inspector/target_agent.cc                 | 48 ++++++++++---------
 src/inspector/target_agent.h                  | 30 ++++++------
 src/inspector_agent.cc                        | 26 +++++-----
 src/inspector_io.cc                           | 37 +++++++-------
 test/parallel/test-inspector-worker-target.js | 16 +++----
 6 files changed, 81 insertions(+), 77 deletions(-)

diff --git a/src/inspector/node_protocol.pdl b/src/inspector/node_protocol.pdl
index 74de9b52eba887..c72459e2a242f7 100644
--- a/src/inspector/node_protocol.pdl
+++ b/src/inspector/node_protocol.pdl
@@ -241,4 +241,3 @@ experimental domain Target
       SessionID sessionId
       TargetInfo targetInfo
       boolean waitingForDebugger
-      
\ No newline at end of file
diff --git a/src/inspector/target_agent.cc b/src/inspector/target_agent.cc
index 50ee5b16e02489..a556995d056033 100644
--- a/src/inspector/target_agent.cc
+++ b/src/inspector/target_agent.cc
@@ -1,11 +1,4 @@
 #include "target_agent.h"
-#include <iostream>
-#include <memory>
-#include <set>
-#include <string>
-#include <tuple>
-#include <utility>
-#include "inspector/node_string.h"
 #include "inspector/worker_inspector.h"
 #include "main_thread_interface.h"
 
@@ -13,35 +6,34 @@ namespace node {
 namespace inspector {
 namespace protocol {
 
-std::unordered_map<int,std::shared_ptr<MainThreadHandle>> TargetAgent::target_session_id_worker_map_ = std::unordered_map<int, std::shared_ptr<MainThreadHandle>>();
-
-
+std::unordered_map<int, std::shared_ptr<MainThreadHandle>>
+    TargetAgent::target_session_id_worker_map_ =
+        std::unordered_map<int, std::shared_ptr<MainThreadHandle>>();
+int TargetAgent::next_session_id_ = 1;
 class WorkerTargetDelegate : public WorkerDelegate {
  public:
   explicit WorkerTargetDelegate(std::shared_ptr<TargetAgent> target_agent)
       : target_agent_(target_agent) {}
 
-
   void WorkerCreated(const std::string& title,
                      const std::string& url,
                      bool waiting,
                      std::shared_ptr<MainThreadHandle> worker) override {
     std::string target_id = std::to_string(target_agent_->getNextTargetId());
     std::string type = "worker";
-    
+
     target_agent_->targetCreated(target_id, type, title, url);
-    target_agent_->attachedToTarget(worker,target_id, type, title, url);
+    target_agent_->attachedToTarget(worker, target_id, type, title, url);
   }
 
  private:
   const std::shared_ptr<TargetAgent> target_agent_;
 };
 
-std::unique_ptr<Target::TargetInfo> createTargetInfo(
-    const String& target_id,
-    const String& type,
-    const String& title,
-    const String& url) {
+std::unique_ptr<Target::TargetInfo> createTargetInfo(const String& target_id,
+                                                     const String& type,
+                                                     const String& title,
+                                                     const String& url) {
   return Target::TargetInfo::create()
       .setTargetId(target_id)
       .setType(type)
@@ -62,7 +54,8 @@ void TargetAgent::listenWorker(std::weak_ptr<WorkerManager> worker_manager) {
   if (!manager) {
     return;
   }
-  std::unique_ptr<WorkerDelegate> delegate(new WorkerTargetDelegate(shared_from_this()));
+  std::unique_ptr<WorkerDelegate> delegate(
+      new WorkerTargetDelegate(shared_from_this()));
   worker_event_handle_ = manager->SetAutoAttach(std::move(delegate));
 }
 
@@ -72,7 +65,10 @@ void TargetAgent::reset() {
   }
 }
 
-void TargetAgent::targetCreated(const std::string &target_id,const std::string &type,const std::string &title,const std::string &url) {
+void TargetAgent::targetCreated(const std::string& target_id,
+                                const std::string& type,
+                                const std::string& title,
+                                const std::string& url) {
   frontend_->targetCreated(createTargetInfo(target_id, type, title, url));
 }
 
@@ -84,13 +80,19 @@ int TargetAgent::getNextTargetId() {
   return next_target_id_++;
 }
 
-void TargetAgent::attachedToTarget(std::shared_ptr<MainThreadHandle> worker,const std::string &target_id, const std::string &type,const  std::string &title,const  std::string &url) {
+void TargetAgent::attachedToTarget(std::shared_ptr<MainThreadHandle> worker,
+                                   const std::string& target_id,
+                                   const std::string& type,
+                                   const std::string& title,
+                                   const std::string& url) {
   int session_id = getNextSessionId();
   target_session_id_worker_map_[session_id] = worker;
   worker->SetTargetSessionId(session_id);
-  frontend_->attachedToTarget(std::to_string(session_id), createTargetInfo(target_id, type, title, url), true);
+  frontend_->attachedToTarget(std::to_string(session_id),
+                              createTargetInfo(target_id, type, title, url),
+                              true);
 }
 
-} // namespace protocol
+}  // namespace protocol
 }  // namespace inspector
 }  // namespace node
diff --git a/src/inspector/target_agent.h b/src/inspector/target_agent.h
index 8ea3c41f73adc8..cefae4a6ac8b26 100644
--- a/src/inspector/target_agent.h
+++ b/src/inspector/target_agent.h
@@ -4,11 +4,6 @@
 #include "inspector/worker_inspector.h"
 #include "node/inspector/protocol/Target.h"
 
-#include <memory>
-#include <string>
-#include <thread>
-#include <unordered_map>
-
 namespace node {
 
 namespace inspector {
@@ -16,27 +11,33 @@ class TargetInspector;
 
 namespace protocol {
 
-class TargetAgent : public Target::Backend, public std::enable_shared_from_this<TargetAgent> 
-{
+class TargetAgent : public Target::Backend,
+                    public std::enable_shared_from_this<TargetAgent> {
  public:
-  explicit TargetAgent() {}
-
   void Wire(UberDispatcher* dispatcher);
 
-
-  void targetCreated(const std::string &target_id, const std::string &type,const  std::string &title,const  std::string &url);
-  void attachedToTarget(std::shared_ptr<MainThreadHandle> worker,const std::string &target_id, const std::string &type,const  std::string &title,const  std::string &url);
+  void targetCreated(const std::string& target_id,
+                     const std::string& type,
+                     const std::string& title,
+                     const std::string& url);
+  void attachedToTarget(std::shared_ptr<MainThreadHandle> worker,
+                        const std::string& target_id,
+                        const std::string& type,
+                        const std::string& title,
+                        const std::string& url);
 
   int getNextTargetId();
 
   void listenWorker(std::weak_ptr<WorkerManager> worker_manager);
   void reset();
-  static std::unordered_map<int,std::shared_ptr<MainThreadHandle>> target_session_id_worker_map_;
+  static std::unordered_map<int, std::shared_ptr<MainThreadHandle>>
+      target_session_id_worker_map_;
+
  private:
   int getNextSessionId();
   std::shared_ptr<Target::Frontend> frontend_;
   std::weak_ptr<WorkerManager> worker_manager_;
-  int next_session_id_ = 1;
+  static int next_session_id_;
   int next_target_id_ = 1;
   std::unique_ptr<WorkerManagerEventHandle> worker_event_handle_ = nullptr;
 };
@@ -46,4 +47,3 @@ class TargetAgent : public Target::Backend, public std::enable_shared_from_this<
 }  // namespace node
 
 #endif  // SRC_INSPECTOR_TARGET_AGENT_H_
-
diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc
index 47f2e19f82f5b1..b90d5208cdd7b9 100644
--- a/src/inspector_agent.cc
+++ b/src/inspector_agent.cc
@@ -1,5 +1,4 @@
 #include "inspector_agent.h"
-#include <string>
 
 #include "crdtp/json.h"
 #include "env-inl.h"
@@ -22,7 +21,6 @@
 #include "permission/permission.h"
 #include "timer_wrap-inl.h"
 #include "util-inl.h"
-#include "util.h"
 #include "v8-inspector.h"
 #include "v8-platform.h"
 
@@ -224,11 +222,10 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
                        const std::unique_ptr<V8Inspector>& inspector,
                        std::shared_ptr<WorkerManager> worker_manager,
                        std::unique_ptr<InspectorSessionDelegate> delegate,
-                       std::shared_ptr<MainThreadHandle> main_thread_,
+                       std::shared_ptr<MainThreadHandle> main_thread,
                        bool prevent_shutdown)
-      : delegate_(std::move(delegate)), main_thread_(main_thread_),
-        prevent_shutdown_(prevent_shutdown), retaining_context_(false)
-         {
+      : delegate_(std::move(delegate)), main_thread_(main_thread),
+        prevent_shutdown_(prevent_shutdown), retaining_context_(false) {
     session_ = inspector->connect(CONTEXT_GROUP_ID,
                                   this,
                                   StringView(),
@@ -245,7 +242,7 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
     runtime_agent_->Wire(node_dispatcher_.get());
     network_inspector_ = std::make_unique<NetworkInspector>(env);
     network_inspector_->Wire(node_dispatcher_.get());
-    if(env->options()->experimental_worker_inspection) {
+    if (env->options()->experimental_worker_inspection) {
       target_agent_ = std::make_shared<protocol::TargetAgent>();
       target_agent_->Wire(node_dispatcher_.get());
       target_agent_->listenWorker(worker_manager);
@@ -263,7 +260,7 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
     runtime_agent_.reset();  // Dispose before the dispatchers
     network_inspector_->Disable();
     network_inspector_.reset();  // Dispose before the dispatchers
-    if(target_agent_) {
+    if (target_agent_) {
       target_agent_->reset();
     }
   }
@@ -369,17 +366,18 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
     }
     std::optional<int> target_session_id = main_thread_->GetTargetSessionId();
     if (target_session_id.has_value()) {
+      std::string raw_message = protocol::StringUtil::StringViewToUtf8(message);
       std::unique_ptr<protocol::DictionaryValue> value =
           protocol::DictionaryValue::cast(
-              JsonUtil::parseJSON(message));
+              JsonUtil::parseJSON(raw_message));
       std::string target_session_id_str = std::to_string(*target_session_id);
       value->setString("sessionId", target_session_id_str);
       std::string json = serializeToJSON(std::move(value));
-
-      delegate_->SendMessageToFrontend(Utf8ToStringView(json)->string());
+      delegate_->SendMessageToFrontend(
+        Utf8ToStringView(json)->string());
+    } else {
+      delegate_->SendMessageToFrontend(message);
     }
-
-    delegate_->SendMessageToFrontend(message);
   }
 
   void sendMessageToFrontend(const std::string& message) {
@@ -414,7 +412,7 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
   std::unique_ptr<NetworkInspector> network_inspector_;
   std::unique_ptr<InspectorSessionDelegate> delegate_;
   std::unique_ptr<v8_inspector::V8InspectorSession> session_;
-  std::unique_ptr<protocol::UberDispatcher> node_dispatcher_;
+  std::unique_ptr<UberDispatcher> node_dispatcher_;
   std::shared_ptr<MainThreadHandle> main_thread_;
   bool prevent_shutdown_;
   bool retaining_context_;
diff --git a/src/inspector_io.cc b/src/inspector_io.cc
index c28602b0ca0d3c..4a777f11856448 100644
--- a/src/inspector_io.cc
+++ b/src/inspector_io.cc
@@ -6,6 +6,7 @@
 #include "inspector/main_thread_interface.h"
 #include "inspector/node_json.h"
 #include "inspector/node_string.h"
+#include "inspector/target_agent.h"
 #include "inspector_socket_server.h"
 #include "ncrypto.h"
 #include "node.h"
@@ -14,7 +15,6 @@
 #include "util-inl.h"
 #include "v8-inspector.h"
 #include "zlib.h"
-#include "inspector/target_agent.h"
 
 #include <deque>
 #include <cstring>
@@ -343,11 +343,11 @@ void InspectorIoDelegate::StartSession(int session_id,
   fprintf(stderr, "Debugger attached.\n");
 }
 
-std::optional<std::string> InspectorIoDelegate::GetTargetSessionId(const std::string& message) {
-  const std::string_view view(message.data(), message.size());
+std::optional<std::string> InspectorIoDelegate::GetTargetSessionId(
+    const std::string& message) {
+  std::string_view view(message.data(), message.size());
   std::unique_ptr<protocol::DictionaryValue> value =
-      protocol::DictionaryValue::cast(
-          JsonUtil::parseJSON(view));
+      protocol::DictionaryValue::cast(JsonUtil::parseJSON(view));
   protocol::String target_session_id;
   protocol::Value* target_session_id_value = value->get("sessionId");
   if (target_session_id_value) {
@@ -362,34 +362,39 @@ std::optional<std::string> InspectorIoDelegate::GetTargetSessionId(const std::st
 
 void InspectorIoDelegate::MessageReceived(int session_id,
                                           const std::string& message) {
-  std::optional<std::string> target_session_id_str = GetTargetSessionId(message);
+  std::optional<std::string> target_session_id_str =
+      GetTargetSessionId(message);
   std::shared_ptr<MainThreadHandle> worker = nullptr;
   int merged_session_id = session_id;
-  if(!target_session_id_str->empty()) {
+  if (!target_session_id_str->empty()) {
     int target_session_id = std::stoi(*target_session_id_str);
-    worker = protocol::TargetAgent::target_session_id_worker_map_[target_session_id];
-    if(worker) {
+    worker =
+        protocol::TargetAgent::target_session_id_worker_map_[target_session_id];
+    if (worker) {
       merged_session_id += target_session_id << 16;
     }
   }
 
   auto session = sessions_.find(merged_session_id);
 
-  if(session == sessions_.end()) {
+  if (session == sessions_.end()) {
     std::unique_ptr<InspectorSession> session;
-    if(worker) {
+    if (worker) {
       session = worker->Connect(
-        std::unique_ptr<InspectorSessionDelegate>(
-            new IoSessionDelegate(request_queue_->handle(), session_id)), true);
+          std::unique_ptr<InspectorSessionDelegate>(
+              new IoSessionDelegate(request_queue_->handle(), session_id)),
+          true);
     } else {
       session = main_thread_->Connect(
-        std::unique_ptr<InspectorSessionDelegate>(
-            new IoSessionDelegate(request_queue_->handle(), session_id)), true);
+          std::unique_ptr<InspectorSessionDelegate>(
+              new IoSessionDelegate(request_queue_->handle(), session_id)),
+          true);
     }
 
     if (session) {
       sessions_[merged_session_id] = std::move(session);
-      sessions_[merged_session_id]->Dispatch(Utf8ToStringView(message)->string());
+      sessions_[merged_session_id]->Dispatch(
+          Utf8ToStringView(message)->string());
     } else {
       fprintf(stderr, "Failed to connect to inspector session.\n");
     }
diff --git a/test/parallel/test-inspector-worker-target.js b/test/parallel/test-inspector-worker-target.js
index 034fc5a6aebd73..0470a5da33a90d 100644
--- a/test/parallel/test-inspector-worker-target.js
+++ b/test/parallel/test-inspector-worker-target.js
@@ -1,4 +1,4 @@
-// Flags: --experimental-worker-inspection
+// Flags: --inspect=0 --experimental-worker-inspection
 'use strict';
 
 const common = require('../common');
@@ -14,14 +14,14 @@ const session = new Session();
 
 session.connect();
 
-new Worker(fixtures.path("worker-script.mjs"), { type: 'module' });
-session.on("Target.targetCreated", common.mustCall(({ params }) => {
+new Worker(fixtures.path('worker-script.mjs'), { type: 'module' });
+session.on('Target.targetCreated', common.mustCall(({ params }) => {
   const targetInfo = params.targetInfo;
-  assert.strictEqual(targetInfo.type, "worker");
-  assert.ok(targetInfo.url.includes("worker-script.mjs"));
-  assert.strictEqual(targetInfo.targetId, "1");
+  assert.strictEqual(targetInfo.type, 'worker');
+  assert.ok(targetInfo.url.includes('worker-script.mjs'));
+  assert.strictEqual(targetInfo.targetId, '1');
 }));
 
-session.on("Target.attachedToTarget", common.mustCall(({ params }) => {
-  assert.strictEqual(params.sessionId, "1");
+session.on('Target.attachedToTarget', common.mustCall(({ params }) => {
+  assert.strictEqual(params.sessionId, '1');
 }));

From 234a139206be2fb43093324b657904b872d42036 Mon Sep 17 00:00:00 2001
From: islandryu <shimaryuhei@gmail.com>
Date: Thu, 30 Jan 2025 21:13:48 +0900
Subject: [PATCH 4/7] format

---
 doc/api/cli.md                        |  3 +--
 src/inspector/main_thread_interface.h |  5 +----
 src/inspector_agent.cc                | 15 +++++++--------
 3 files changed, 9 insertions(+), 14 deletions(-)

diff --git a/doc/api/cli.md b/doc/api/cli.md
index b24381e6d48bc7..098ef9d33b2b66 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -1140,8 +1140,7 @@ Enable experimental [`Web Storage`][] support.
 
 <!-- YAML
 added:
-  - v22.14.0
-  - v20.19.0
+  - v22.13.1
 -->
 
 > Stability: 1 - Experimental
diff --git a/src/inspector/main_thread_interface.h b/src/inspector/main_thread_interface.h
index 975821773d197f..3311f9df014a39 100644
--- a/src/inspector/main_thread_interface.h
+++ b/src/inspector/main_thread_interface.h
@@ -60,10 +60,7 @@ class MainThreadHandle : public std::enable_shared_from_this<MainThreadHandle> {
   void SetTargetSessionId(int target_session_id) {
     target_session_id_ = target_session_id;
   }
-  std::optional<int> GetTargetSessionId() {
-    return target_session_id_;
-  }
-
+  std::optional<int> GetTargetSessionId() { return target_session_id_; }
 
  private:
   void Reset();
diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc
index b90d5208cdd7b9..89c7365d17b801 100644
--- a/src/inspector_agent.cc
+++ b/src/inspector_agent.cc
@@ -224,8 +224,10 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
                        std::unique_ptr<InspectorSessionDelegate> delegate,
                        std::shared_ptr<MainThreadHandle> main_thread,
                        bool prevent_shutdown)
-      : delegate_(std::move(delegate)), main_thread_(main_thread),
-        prevent_shutdown_(prevent_shutdown), retaining_context_(false) {
+      : delegate_(std::move(delegate)),
+        main_thread_(main_thread),
+        prevent_shutdown_(prevent_shutdown),
+        retaining_context_(false) {
     session_ = inspector->connect(CONTEXT_GROUP_ID,
                                   this,
                                   StringView(),
@@ -346,8 +348,7 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
   // crdtp::FrontendChannel
   void FlushProtocolNotifications() override {}
 
-  std::string serializeToJSON(
-    std::unique_ptr<Serializable> message) {
+  std::string serializeToJSON(std::unique_ptr<Serializable> message) {
     std::vector<uint8_t> cbor = message->Serialize();
     std::string json;
     crdtp::Status status = ConvertCBORToJSON(crdtp::SpanFrom(cbor), &json);
@@ -368,13 +369,11 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
     if (target_session_id.has_value()) {
       std::string raw_message = protocol::StringUtil::StringViewToUtf8(message);
       std::unique_ptr<protocol::DictionaryValue> value =
-          protocol::DictionaryValue::cast(
-              JsonUtil::parseJSON(raw_message));
+          protocol::DictionaryValue::cast(JsonUtil::parseJSON(raw_message));
       std::string target_session_id_str = std::to_string(*target_session_id);
       value->setString("sessionId", target_session_id_str);
       std::string json = serializeToJSON(std::move(value));
-      delegate_->SendMessageToFrontend(
-        Utf8ToStringView(json)->string());
+      delegate_->SendMessageToFrontend(Utf8ToStringView(json)->string());
     } else {
       delegate_->SendMessageToFrontend(message);
     }

From 01011f6aac5e22716a08ba77272d5f3f76bb719e Mon Sep 17 00:00:00 2001
From: islandryu <shimaryuhei@gmail.com>
Date: Mon, 3 Feb 2025 22:09:53 +0900
Subject: [PATCH 5/7] fix test

---
 test/fixtures/inspect-worker/index.js         |  3 +
 test/fixtures/inspect-worker/worker.js        |  4 ++
 test/parallel/test-inspector-worker-target.js | 55 +++++++++++++------
 3 files changed, 46 insertions(+), 16 deletions(-)
 create mode 100644 test/fixtures/inspect-worker/index.js
 create mode 100644 test/fixtures/inspect-worker/worker.js

diff --git a/test/fixtures/inspect-worker/index.js b/test/fixtures/inspect-worker/index.js
new file mode 100644
index 00000000000000..864176a7ba2126
--- /dev/null
+++ b/test/fixtures/inspect-worker/index.js
@@ -0,0 +1,3 @@
+const { Worker } = require('worker_threads');
+
+new Worker(__dirname + '/worker.js', { type: 'module' });
\ No newline at end of file
diff --git a/test/fixtures/inspect-worker/worker.js b/test/fixtures/inspect-worker/worker.js
new file mode 100644
index 00000000000000..ebae421509e794
--- /dev/null
+++ b/test/fixtures/inspect-worker/worker.js
@@ -0,0 +1,4 @@
+console.log("worker thread");
+process.on('exit', () => {
+  console.log('Worker1: Exiting...');
+});
\ No newline at end of file
diff --git a/test/parallel/test-inspector-worker-target.js b/test/parallel/test-inspector-worker-target.js
index 0470a5da33a90d..521d0933308508 100644
--- a/test/parallel/test-inspector-worker-target.js
+++ b/test/parallel/test-inspector-worker-target.js
@@ -1,27 +1,50 @@
-// Flags: --inspect=0 --experimental-worker-inspection
 'use strict';
 
 const common = require('../common');
 const fixtures = require('../common/fixtures');
-const { Worker } = require('worker_threads');
 
 common.skipIfInspectorDisabled();
 
-const assert = require('assert');
-const { Session } = require('inspector');
+const { NodeInstance } = require('../common/inspector-helper.js');
 
-const session = new Session();
+(async () => {
+  const child = new NodeInstance(['--inspect-brk', '--experimental-worker-inspection'],
+                                 '',
+                                 fixtures.path('inspect-worker/index.js')
+  );
 
-session.connect();
+  const session = await child.connectInspectorSession();
+  await session.send({ method: 'NodeRuntime.enable' });
+  await session.waitForNotification('NodeRuntime.waitingForDebugger');
+  await session.send({ method: 'Runtime.enable' });
+  await session.send({ method: 'Debugger.enable' });
+  await session.send({ method: 'Runtime.runIfWaitingForDebugger' });
+  await session.send({ method: 'NodeRuntime.disable' });
+  await session.waitForNotification((notification) => {
+    // // The main assertion here is that we do hit the loader script first.
+    return notification.method === 'Debugger.scriptParsed' &&
+            notification.params.url === 'node:internal/bootstrap/realm';
+  });
 
-new Worker(fixtures.path('worker-script.mjs'), { type: 'module' });
-session.on('Target.targetCreated', common.mustCall(({ params }) => {
-  const targetInfo = params.targetInfo;
-  assert.strictEqual(targetInfo.type, 'worker');
-  assert.ok(targetInfo.url.includes('worker-script.mjs'));
-  assert.strictEqual(targetInfo.targetId, '1');
-}));
+  await session.waitForNotification('Debugger.paused');
+  await session.send({ method: 'Debugger.resume' });
 
-session.on('Target.attachedToTarget', common.mustCall(({ params }) => {
-  assert.strictEqual(params.sessionId, '1');
-}));
+  const sessionId = '1';
+  await session.waitForNotification('Target.targetCreated');
+  await session.waitForNotification((notification) => {
+    return notification.method === 'Target.attachedToTarget' &&
+           notification.params.sessionId === sessionId;
+  });
+
+  await session.send({ method: 'Runtime.enable', sessionId });
+  await session.send({ method: 'Debugger.enable', sessionId });
+  await session.send({ method: 'Runtime.runIfWaitingForDebugger', sessionId });
+  await session.send({ method: 'NodeRuntime.enable', sessionId });
+  await session.waitForNotification((notification) => {
+    return notification.method === 'Debugger.scriptParsed' &&
+            notification.params.url === 'node:internal/bootstrap/realm';
+  });
+  await session.waitForNotification('Debugger.paused');
+  await session.send({ method: 'Debugger.resume', sessionId });
+  await session.waitForDisconnect();
+})().then(common.mustCall());

From cde7b0977db4e197eb8a2b0df6657603a4a0fe70 Mon Sep 17 00:00:00 2001
From: islandryu <shimaryuhei@gmail.com>
Date: Sat, 8 Feb 2025 20:13:16 +0900
Subject: [PATCH 6/7] support setAutoAttach

---
 src/inspector/node_protocol.pdl               |  4 ++
 src/inspector/target_agent.cc                 | 46 ++++++++++++++--
 src/inspector/target_agent.h                  | 44 +++++++++++----
 test/fixtures/inspect-worker/index.js         |  2 +-
 test/fixtures/inspect-worker/worker.js        |  2 +-
 test/parallel/test-inspector-worker-target.js | 53 +++++++++++--------
 6 files changed, 111 insertions(+), 40 deletions(-)

diff --git a/src/inspector/node_protocol.pdl b/src/inspector/node_protocol.pdl
index c72459e2a242f7..25fb0a6e2215b3 100644
--- a/src/inspector/node_protocol.pdl
+++ b/src/inspector/node_protocol.pdl
@@ -241,3 +241,7 @@ experimental domain Target
       SessionID sessionId
       TargetInfo targetInfo
       boolean waitingForDebugger
+  command setAutoAttach
+    parameters
+      boolean autoAttach
+      boolean waitForDebuggerOnStart
diff --git a/src/inspector/target_agent.cc b/src/inspector/target_agent.cc
index a556995d056033..d059705767371e 100644
--- a/src/inspector/target_agent.cc
+++ b/src/inspector/target_agent.cc
@@ -1,4 +1,5 @@
 #include "target_agent.h"
+#include "crdtp/dispatch.h"
 #include "inspector/worker_inspector.h"
 #include "main_thread_interface.h"
 
@@ -19,11 +20,7 @@ class WorkerTargetDelegate : public WorkerDelegate {
                      const std::string& url,
                      bool waiting,
                      std::shared_ptr<MainThreadHandle> worker) override {
-    std::string target_id = std::to_string(target_agent_->getNextTargetId());
-    std::string type = "worker";
-
-    target_agent_->targetCreated(target_id, type, title, url);
-    target_agent_->attachedToTarget(worker, target_id, type, title, url);
+    target_agent_->createAndAttachIfNecessary(worker, title, url);
   }
 
  private:
@@ -49,6 +46,22 @@ void TargetAgent::Wire(UberDispatcher* dispatcher) {
   Target::Dispatcher::wire(dispatcher, this);
 }
 
+void TargetAgent::createAndAttachIfNecessary(
+    std::shared_ptr<MainThreadHandle> worker,
+    const std::string& title,
+    const std::string& url) {
+  std::string target_id = std::to_string(getNextTargetId());
+  std::string type = "worker";
+
+  targetCreated(target_id, type, title, url);
+  bool attached = false;
+  if (auto_attach_) {
+    attached = true;
+    attachedToTarget(worker, target_id, type, title, url);
+  }
+  targets_.push_back({target_id, type, title, url, worker, attached});
+}
+
 void TargetAgent::listenWorker(std::weak_ptr<WorkerManager> worker_manager) {
   auto manager = worker_manager.lock();
   if (!manager) {
@@ -93,6 +106,29 @@ void TargetAgent::attachedToTarget(std::shared_ptr<MainThreadHandle> worker,
                               true);
 }
 
+// TODO(islandryu): Currently, setAutoAttach applies the main thread's value to
+// all threads. Modify it to be managed per worker thread.
+crdtp::DispatchResponse TargetAgent::setAutoAttach(
+    bool auto_attach, bool wait_for_debugger_on_start) {
+  auto_attach_ = auto_attach;
+  wait_for_debugger_on_start_ = wait_for_debugger_on_start;
+
+  if (auto_attach) {
+    for (auto& target : targets_) {
+      if (!target.attached) {
+        target.attached = true;
+        attachedToTarget(target.worker,
+                         target.target_id,
+                         target.type,
+                         target.title,
+                         target.url);
+      }
+    }
+  }
+
+  return DispatchResponse::Success();
+}
+
 }  // namespace protocol
 }  // namespace inspector
 }  // namespace node
diff --git a/src/inspector/target_agent.h b/src/inspector/target_agent.h
index cefae4a6ac8b26..19bb6b309f0932 100644
--- a/src/inspector/target_agent.h
+++ b/src/inspector/target_agent.h
@@ -1,6 +1,8 @@
 #ifndef SRC_INSPECTOR_TARGET_AGENT_H_
 #define SRC_INSPECTOR_TARGET_AGENT_H_
 
+#include <unordered_map>
+#include <vector>
 #include "inspector/worker_inspector.h"
 #include "node/inspector/protocol/Target.h"
 
@@ -11,35 +13,57 @@ class TargetInspector;
 
 namespace protocol {
 
+struct TargetInfo {
+  std::string target_id;
+  std::string type;
+  std::string title;
+  std::string url;
+  std::shared_ptr<MainThreadHandle> worker;
+  bool attached;
+};
+
 class TargetAgent : public Target::Backend,
                     public std::enable_shared_from_this<TargetAgent> {
  public:
   void Wire(UberDispatcher* dispatcher);
 
-  void targetCreated(const std::string& target_id,
-                     const std::string& type,
-                     const std::string& title,
-                     const std::string& url);
-  void attachedToTarget(std::shared_ptr<MainThreadHandle> worker,
-                        const std::string& target_id,
-                        const std::string& type,
-                        const std::string& title,
-                        const std::string& url);
+  void createAndAttachIfNecessary(std::shared_ptr<MainThreadHandle> worker,
+                                  const std::string& title,
+                                  const std::string& url);
 
-  int getNextTargetId();
+  DispatchResponse setAutoAttach(bool auto_attach,
+                                 bool wait_for_debugger_on_start) override;
 
   void listenWorker(std::weak_ptr<WorkerManager> worker_manager);
   void reset();
   static std::unordered_map<int, std::shared_ptr<MainThreadHandle>>
       target_session_id_worker_map_;
 
+  bool isThisThread(MainThreadHandle* worker) { return worker == main_thread_; }
+
  private:
+  int getNextTargetId();
   int getNextSessionId();
+  void targetCreated(const std::string& target_id,
+                     const std::string& type,
+                     const std::string& title,
+                     const std::string& url);
+  void attachedToTarget(std::shared_ptr<MainThreadHandle> worker,
+                        const std::string& target_id,
+                        const std::string& type,
+                        const std::string& title,
+                        const std::string& url);
   std::shared_ptr<Target::Frontend> frontend_;
   std::weak_ptr<WorkerManager> worker_manager_;
   static int next_session_id_;
   int next_target_id_ = 1;
   std::unique_ptr<WorkerManagerEventHandle> worker_event_handle_ = nullptr;
+  bool auto_attach_ = false;
+  // TODO(islandryu): If false, implement it so that each thread does not wait
+  // for the worker to execute.
+  bool wait_for_debugger_on_start_ = true;
+  std::vector<TargetInfo> targets_;
+  MainThreadHandle* main_thread_;
 };
 
 }  // namespace protocol
diff --git a/test/fixtures/inspect-worker/index.js b/test/fixtures/inspect-worker/index.js
index 864176a7ba2126..b0f883ef4b0453 100644
--- a/test/fixtures/inspect-worker/index.js
+++ b/test/fixtures/inspect-worker/index.js
@@ -1,3 +1,3 @@
 const { Worker } = require('worker_threads');
 
-new Worker(__dirname + '/worker.js', { type: 'module' });
\ No newline at end of file
+new Worker(__dirname + '/worker.js', { type: 'module' });
diff --git a/test/fixtures/inspect-worker/worker.js b/test/fixtures/inspect-worker/worker.js
index ebae421509e794..9729bd7b41c6e1 100644
--- a/test/fixtures/inspect-worker/worker.js
+++ b/test/fixtures/inspect-worker/worker.js
@@ -1,4 +1,4 @@
 console.log("worker thread");
 process.on('exit', () => {
   console.log('Worker1: Exiting...');
-});
\ No newline at end of file
+});
diff --git a/test/parallel/test-inspector-worker-target.js b/test/parallel/test-inspector-worker-target.js
index 521d0933308508..f8655aea59f076 100644
--- a/test/parallel/test-inspector-worker-target.js
+++ b/test/parallel/test-inspector-worker-target.js
@@ -7,44 +7,51 @@ common.skipIfInspectorDisabled();
 
 const { NodeInstance } = require('../common/inspector-helper.js');
 
-(async () => {
-  const child = new NodeInstance(['--inspect-brk', '--experimental-worker-inspection'],
+async function setupInspector(session, sessionId = undefined) {
+  await session.send({ method: 'NodeRuntime.enable', sessionId });
+  await session.waitForNotification('NodeRuntime.waitingForDebugger');
+  await session.send({ method: 'Runtime.enable', sessionId });
+  await session.send({ method: 'Debugger.enable', sessionId });
+  await session.send({ method: 'Runtime.runIfWaitingForDebugger', sessionId });
+  await session.send({ method: 'NodeRuntime.disable', sessionId });
+  await session.waitForNotification((notification) => {
+    return notification.method === 'Debugger.scriptParsed' &&
+            notification.params.url === 'node:internal/bootstrap/realm' &&
+            notification.sessionId === sessionId;
+  });
+}
+
+async function test(isSetAutoAttachBeforeExecution) {
+  const child = new NodeInstance(['--inspect-brk=0', '--experimental-worker-inspection'],
                                  '',
                                  fixtures.path('inspect-worker/index.js')
   );
 
+
   const session = await child.connectInspectorSession();
-  await session.send({ method: 'NodeRuntime.enable' });
-  await session.waitForNotification('NodeRuntime.waitingForDebugger');
-  await session.send({ method: 'Runtime.enable' });
-  await session.send({ method: 'Debugger.enable' });
-  await session.send({ method: 'Runtime.runIfWaitingForDebugger' });
-  await session.send({ method: 'NodeRuntime.disable' });
-  await session.waitForNotification((notification) => {
-    // // The main assertion here is that we do hit the loader script first.
-    return notification.method === 'Debugger.scriptParsed' &&
-            notification.params.url === 'node:internal/bootstrap/realm';
-  });
+  await setupInspector(session);
 
+  if (isSetAutoAttachBeforeExecution) {
+    await session.send({ method: 'Target.setAutoAttach', params: { autoAttach: true, waitForDebuggerOnStart: true } });
+  }
   await session.waitForNotification('Debugger.paused');
   await session.send({ method: 'Debugger.resume' });
 
   const sessionId = '1';
   await session.waitForNotification('Target.targetCreated');
+
+  if (!isSetAutoAttachBeforeExecution) {
+    await session.send({ method: 'Target.setAutoAttach', params: { autoAttach: true, waitForDebuggerOnStart: true } });
+  }
   await session.waitForNotification((notification) => {
     return notification.method === 'Target.attachedToTarget' &&
            notification.params.sessionId === sessionId;
   });
-
-  await session.send({ method: 'Runtime.enable', sessionId });
-  await session.send({ method: 'Debugger.enable', sessionId });
-  await session.send({ method: 'Runtime.runIfWaitingForDebugger', sessionId });
-  await session.send({ method: 'NodeRuntime.enable', sessionId });
-  await session.waitForNotification((notification) => {
-    return notification.method === 'Debugger.scriptParsed' &&
-            notification.params.url === 'node:internal/bootstrap/realm';
-  });
+  await setupInspector(session, sessionId);
   await session.waitForNotification('Debugger.paused');
   await session.send({ method: 'Debugger.resume', sessionId });
   await session.waitForDisconnect();
-})().then(common.mustCall());
+}
+
+test(true);
+test(false);

From b669db4c47db39b034b02dedac9c8c0fdaf35d73 Mon Sep 17 00:00:00 2001
From: islandryu <shimaryuhei@gmail.com>
Date: Sun, 9 Feb 2025 18:32:09 +0900
Subject: [PATCH 7/7] fix stoi error

---
 src/inspector_io.cc | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/src/inspector_io.cc b/src/inspector_io.cc
index 4a777f11856448..c197d15f135fd2 100644
--- a/src/inspector_io.cc
+++ b/src/inspector_io.cc
@@ -366,12 +366,17 @@ void InspectorIoDelegate::MessageReceived(int session_id,
       GetTargetSessionId(message);
   std::shared_ptr<MainThreadHandle> worker = nullptr;
   int merged_session_id = session_id;
-  if (!target_session_id_str->empty()) {
-    int target_session_id = std::stoi(*target_session_id_str);
-    worker =
-        protocol::TargetAgent::target_session_id_worker_map_[target_session_id];
-    if (worker) {
-      merged_session_id += target_session_id << 16;
+  if (target_session_id_str) {
+    bool is_number = std::all_of(target_session_id_str->begin(),
+                                 target_session_id_str->end(),
+                                 ::isdigit);
+    if (is_number) {
+      int target_session_id = std::stoi(*target_session_id_str);
+      worker = protocol::TargetAgent::target_session_id_worker_map_
+          [target_session_id];
+      if (worker) {
+        merged_session_id += target_session_id << 16;
+      }
     }
   }