put method api

Author: islandryu

doc/api/cli.md

@@ -1066,8 +1066,7 @@ added:
 
 > Stability: 1.1 - Active Development
 
-Enables the Network.loadNetworkResource method in the Chrome DevTools Protocol (CDP) during debugging sessions.
-This feature allows DevTools to fetch additional resources directly through the inspector backend.
+Enable experimental support for inspector network resources.
 
 ### `--experimental-loader=module`
 

doc/api/inspector.md

@@ -598,6 +598,43 @@ This feature is only available with the `--experimental-network-inspection` flag
 Broadcasts the `Network.loadingFailed` event to connected frontends. This event indicates that
 HTTP request has failed to load.
 
+### `inspector.NetworkResources.put`
+
+<!-- YAML
+added:
+  - REPLACEME
+-->
+
+> Stability: 1.1 - Active Development
+
+This feature is only available with the `--experimental-inspector-network-resource` flag enabled.
+
+The inspector.NetworkResources.put method is used to provide a response for a loadNetworkResource
+request issued via the Chrome DevTools Protocol (CDP).
+This is typically triggered when a source map is specified by URL, and a DevTools frontend—such as
+Chrome—requests the resource to retrieve the source map.
+
+This method allows developers to predefine the resource content to be served in response to such CDP requests.
+
+```js
+const inspector = require('node:inspector');
+// By preemptively calling put to register the resource, a source map can be resolved when
+// a loadNetworkResource request is made from the frontend.
+async function setNetworkResources() {
+  const mapUrl = 'http://localhost:3000/dist/app.js.map';
+  const tsUrl = 'http://localhost:3000/src/app.ts';
+  const distAppJsMap = await fetch(mapUrl).then((res) => res.text());
+  const srcAppTs = await fetch(tsUrl).then((res) => res.text());
+  inspector.NetworkResources.put(mapUrl, distAppJsMap);
+  inspector.NetworkResources.put(tsUrl, srcAppTs);
+};
+setNetworkResources().then(() => {
+  require('./dist/app');
+});
+```
+
+For more details, see the official CDP documentation: [Network.loadNetworkResource](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-loadNetworkResource)
+
 ## Support of breakpoints
 
 The Chrome DevTools Protocol [`Debugger` domain][] allows an

lib/inspector.js

@@ -36,6 +36,9 @@ const {
 } = require('internal/validators');
 const { isMainThread } = require('worker_threads');
 const { _debugEnd } = internalBinding('process_methods');
+const {
+  put,
+} = require('internal/inspector/network_resources');
 
 const {
   Connection,
@@ -218,6 +221,10 @@ const Network = {
   dataReceived: (params) => broadcastToFrontend('Network.dataReceived', params),
 };
 
+const NetworkResources = {
+  put,
+};
+
 module.exports = {
   open: inspectorOpen,
   close: _debugEnd,
@@ -226,4 +233,5 @@ module.exports = {
   console,
   Session,
   Network,
+  NetworkResources,
 };

lib/internal/inspector/fall_through_handle.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const { getOptionValue } = require('internal/options');
+const { validateString } = require('internal/validators');
+const { putNetworkResource } = internalBinding('inspector');
+
+/**
+ * Registers a resource for the inspector using the internal 'putNetworkResource' binding.
+ * @param {string} url - The URL of the resource.
+ * @param {string} data - The content of the resource to provide.
+ */
+function put(url, data) {
+  if (!getOptionValue('--experimental-inspector-network-resource')) {
+    process.emitWarning(
+      'The --experimental-inspector-network-resource option is not enabled. ' +
+        'Please enable it to use the putNetworkResource function');
+    return;
+  }
+  validateString(url, 'url');
+  validateString(data, 'data');
+
+  putNetworkResource(url, data);
+}
+
+module.exports = {
+  put,
+};

lib/internal/inspector/load_network_resource_worker.js

@@ -136,10 +136,6 @@ function runEntryPointWithESMLoader(callback) {
  * @param {string} main - First positional CLI argument, such as `'entry.js'` from `node entry.js`
  */
 function executeUserEntryPoint(main = process.argv[1]) {
-  if (getOptionValue('--experimental-inspector-network-resource')) {
-    require('internal/inspector/fall_through_handle').spawnLoadNetworkResourceWorker();
-  }
-
   let useESMLoader;
   let resolvedMain;
   if (getOptionValue('--entry-url')) {

lib/internal/inspector/network_resources.js

@@ -1,8 +1,10 @@
 #include "io_agent.h"
 #include <algorithm>
+#include <iostream>
 #include <string>
+#include <string_view>
 #include "crdtp/dispatch.h"
-#include "node_mutex.h"
+#include "inspector/network_resource_manager.h"
 
 namespace node::inspector::protocol {
 
@@ -11,75 +13,67 @@ void IoAgent::Wire(UberDispatcher* dispatcher) {
   IO::Dispatcher::wire(dispatcher, this);
 }
 
-std::unordered_map<int, int> IoAgent::offset_map_;
-std::unordered_map<int, std::string> IoAgent::data_map_;
-std::atomic<int> IoAgent::stream_counter_{1};
-Mutex IoAgent::data_mutex_;
-
-int IoAgent::setData(const std::string& value) {
-  int key = getNextStreamId();
-  Mutex::ScopedLock lock(data_mutex_);
-  data_map_[key] = value;
-
-  return key;
-}
-
-int IoAgent::getNextStreamId() {
-  return stream_counter_++;
-}
-
 DispatchResponse IoAgent::read(const String& in_handle,
                                Maybe<int> in_offset,
                                Maybe<int> in_size,
                                String* out_data,
                                bool* out_eof) {
-  Mutex::ScopedReadLock lock(data_mutex_);
   std::string in_handle_str = in_handle;
-  int stream_id = 0;
+  uint64_t stream_id = 0;
   bool is_number =
       std::all_of(in_handle_str.begin(), in_handle_str.end(), ::isdigit);
   if (!is_number) {
-    out_data = new String("");
+    *out_data = "";
     *out_eof = true;
     return DispatchResponse::Success();
   }
-  stream_id = std::stoi(in_handle_str);
+  stream_id = std::stoull(in_handle_str);
+
+  std::string url = NetworkResourceManager::GetUrlForStreamId(stream_id);
+  if (url.empty()) {
+    *out_data = "";
+    *out_eof = true;
+    return DispatchResponse::Success();
+  }
+  std::string txt = NetworkResourceManager::Get(url);
+  std::string_view txt_view(txt);
 
-  std::string txt = data_map_[stream_id];
   int offset = 0;
+  bool offset_was_specified = false;
   if (in_offset.isJust()) {
     offset = in_offset.fromJust();
+    offset_was_specified = true;
   } else if (offset_map_.find(stream_id) != offset_map_.end()) {
     offset = offset_map_[stream_id];
   }
   int size = 1 << 20;
   if (in_size.isJust()) {
     size = in_size.fromJust();
   }
-
-  if (static_cast<std::size_t>(offset) < txt.length()) {
-    std::string out_txt = txt.substr(offset, size);
-    out_data->assign(out_txt);
+  if (static_cast<std::size_t>(offset) < txt_view.length()) {
+    std::string_view out_view = txt_view.substr(offset, size);
+    out_data->assign(out_view.data(), out_view.size());
     *out_eof = false;
+    if (!offset_was_specified) {
+      offset_map_[stream_id] = offset + size;
+    }
   } else {
+    *out_data = "";
     *out_eof = true;
   }
 
-  offset_map_[stream_id] = offset + size;
-
   return DispatchResponse::Success();
 }
 
 DispatchResponse IoAgent::close(const String& in_handle) {
-  Mutex::ScopedWriteLock lock(data_mutex_);
   std::string in_handle_str = in_handle;
-  int stream_id = 0;
+  uint64_t stream_id = 0;
   bool is_number =
       std::all_of(in_handle_str.begin(), in_handle_str.end(), ::isdigit);
   if (is_number) {
-    stream_id = std::stoi(in_handle_str);
-    offset_map_.erase(stream_id);
-    data_map_.erase(stream_id);
+    stream_id = std::stoull(in_handle_str);
+    // Use accessor to erase resource and mapping by stream id
+    NetworkResourceManager::EraseByStreamId(stream_id);
   }
   return DispatchResponse::Success();
 }

lib/internal/modules/run_main.js

@@ -1,9 +1,7 @@
 #ifndef SRC_INSPECTOR_IO_AGENT_H_
 #define SRC_INSPECTOR_IO_AGENT_H_
 
-#include <unordered_map>
 #include "node/inspector/protocol/IO.h"
-#include "node_mutex.h"
 
 namespace node::inspector::protocol {
 
@@ -18,16 +16,9 @@ class IoAgent : public IO::Backend {
                         bool* out_eof) override;
   DispatchResponse close(const String& in_handle) override;
 
-  static int setData(const std::string& value);
-
  private:
   std::shared_ptr<IO::Frontend> frontend_;
-  static int getNextStreamId();
-
-  static std::unordered_map<int, std::string> data_map_;
-  static std::unordered_map<int, int> offset_map_;
-  static std::atomic<int> stream_counter_;
-  static Mutex data_mutex_;
+  std::unordered_map<int, int> offset_map_ = {};  // Maps stream_id to offset
 };
 }  // namespace node::inspector::protocol
 #endif  // SRC_INSPECTOR_IO_AGENT_H_

src/inspector/io_agent.cc

@@ -1,7 +1,8 @@
 #include "network_agent.h"
-#include "debug_utils-inl.h"
 #include <string>
+#include "debug_utils-inl.h"
 #include "env-inl.h"
+#include "inspector/network_resource_manager.h"
 #include "inspector/protocol_helper.h"
 #include "network_inspector.h"
 #include "node_metadata.h"
@@ -208,8 +209,9 @@ std::unique_ptr<protocol::Network::Response> createResponseFromObject(
 }
 
 NetworkAgent::NetworkAgent(NetworkInspector* inspector,
-                           v8_inspector::V8Inspector* v8_inspector)
-    : inspector_(inspector), v8_inspector_(v8_inspector) {
+                           v8_inspector::V8Inspector* v8_inspector,
+                           Environment* env)
+    : inspector_(inspector), v8_inspector_(v8_inspector), env_(env) {
   event_notifier_map_["requestWillBeSent"] = &NetworkAgent::requestWillBeSent;
   event_notifier_map_["responseReceived"] = &NetworkAgent::responseReceived;
   event_notifier_map_["loadingFailed"] = &NetworkAgent::loadingFailed;
@@ -341,7 +343,29 @@ protocol::DispatchResponse NetworkAgent::loadNetworkResource(
     const protocol::String& in_url,
     std::unique_ptr<protocol::Network::LoadNetworkResourcePageResult>*
         out_resource) {
-  return protocol::DispatchResponse::FallThrough();
+  if (!env_->options()->experimental_inspector_network_resource) {
+    return protocol::DispatchResponse::ServerError(
+        "Network resource loading is not enabled. This feature is "
+        "experimental and requires --experimental-inspector-network-resource "
+        "flag to be set.");
+  }
+  std::string data = NetworkResourceManager::Get(in_url);
+  bool found = !data.empty();
+  if (found) {
+    uint64_t stream_id = NetworkResourceManager::GetStreamId(in_url);
+    auto result = protocol::Network::LoadNetworkResourcePageResult::create()
+                      .setSuccess(true)
+                      .setStream(std::to_string(stream_id))
+                      .build();
+    *out_resource = std::move(result);
+    return protocol::DispatchResponse::Success();
+  } else {
+    auto result = protocol::Network::LoadNetworkResourcePageResult::create()
+                      .setSuccess(false)
+                      .build();
+    *out_resource = std::move(result);
+    return protocol::DispatchResponse::Success();
+  }
 }
 
 void NetworkAgent::requestWillBeSent(v8::Local<v8::Context> context,