feat(ext/node): buffer Network.* bodies for inspector body-fetch commands (#34201)

The Node-style inspector Network domain shipped in #32707 plumbed event
broadcast for Network.dataReceived / dataSent / requestWillBeSent /
responseReceived, but the three CDP commands consumers actually use to
pull bodies back out — Network.getResponseBody,
Network.streamResourceContent, and Network.getRequestPostData — weren't
implemented, so any tool that called them got a -32601 method-not-found
error.

This adds a bounded per-process buffer (32 requests max, 10 MB per
request, FIFO eviction) on the inspector that captures bodies as the
events flow through op_inspector_emit_protocol_event, plus dispatcher
handlers for the three commands on both the local-session and WebSocket
paths. Charset handling mirrors Node: utf-8 returns a decoded string,
anything else returns base64. Raw Buffer/Uint8Array data passed to
inspector.Network.dataReceived/.dataSent is base64-encoded at the
polyfill layer to match the wire format consumers expect.

Clears four node_compat tests:
test-inspector-network-data-received.js,
test-inspector-network-data-sent.js,
test-inspector-network-arbitrary-data.js, and
test-inspector-emit-protocol-event.js

Author: bartlomieju

Cargo.lock

@@ -118,8 +118,17 @@ pub fn op_inspector_emit_protocol_event(
   let needs_initiator = event_name == "Network.requestWillBeSent"
     || event_name == "Network.webSocketCreated";
   let needs_has_post_data = event_name == "Network.requestWillBeSent";
+  let needs_capture = matches!(
+    event_name.as_str(),
+    "Network.requestWillBeSent"
+      | "Network.responseReceived"
+      | "Network.loadingFinished"
+      | "Network.loadingFailed"
+      | "Network.dataReceived"
+      | "Network.dataSent"
+  );
 
-  if !needs_initiator && !needs_has_post_data {
+  if !needs_initiator && !needs_has_post_data && !needs_capture {
     inspector.broadcast_to_sessions(&event_name, &params);
     return;
   }
@@ -147,8 +156,16 @@ pub fn op_inspector_emit_protocol_event(
       .or_insert(serde_json::Value::Bool(false));
   }
 
-  let augmented = serde_json::to_string(&parsed).unwrap();
-  inspector.broadcast_to_sessions(&event_name, &augmented);
+  let should_broadcast = if needs_capture {
+    inspector.capture_network_event(&event_name, &parsed)
+  } else {
+    true
+  };
+
+  if should_broadcast {
+    let augmented = serde_json::to_string(&parsed).unwrap();
+    inspector.broadcast_to_sessions(&event_name, &augmented);
+  }
 }
 
 fn capture_initiator(scope: &mut v8::PinScope<'_, '_>) -> serde_json::Value {

ext/node/ops/inspector.rs

@@ -6,6 +6,7 @@
 (function () {
 const { core, primordials } = globalThis.__bootstrap;
 const {
+  op_base64_encode_from_buffer,
   op_get_extras_binding_object,
   op_inspector_close,
   op_inspector_connect,
@@ -53,12 +54,39 @@ function isLoopback(host) {
 const {
   ArrayPrototypePush,
   ArrayPrototypeShift,
+  ObjectAssign,
   SymbolDispose,
   JSONParse,
   JSONStringify,
   SafeMap,
+  TypedArrayPrototypeGetByteLength,
+  TypedArrayPrototypeGetSymbolToStringTag,
+  Uint8Array,
 } = primordials;
 
+function encodeNetworkData(data) {
+  if (data == null) return undefined;
+  if (typeof data === "string") {
+    // Encode UTF-8 string as base64.
+    const buf = core.encode(data);
+    return op_base64_encode_from_buffer(buf, 0, buf.byteLength);
+  }
+  if (TypedArrayPrototypeGetSymbolToStringTag(data) === "Uint8Array") {
+    return op_base64_encode_from_buffer(
+      data,
+      0,
+      TypedArrayPrototypeGetByteLength(data),
+    );
+  }
+  if (data instanceof ArrayBuffer) {
+    const view = new Uint8Array(data);
+    return op_base64_encode_from_buffer(view, 0, view.byteLength);
+  }
+  throw new TypeError(
+    "Expected data to be a string, Buffer, Uint8Array, or ArrayBuffer",
+  );
+}
+
 class Session extends EventEmitter {
   #connection = null;
   #nextId = 1;
@@ -247,6 +275,16 @@ function broadcastToFrontend(eventName, params) {
   op_inspector_emit_protocol_event(eventName, JSONStringify(params ?? {}));
 }
 
+function broadcastNetworkData(eventName, params) {
+  if (params && params.data !== undefined) {
+    const encoded = encodeNetworkData(params.data);
+    if (encoded !== params.data) {
+      params = ObjectAssign({ __proto__: null }, params, { data: encoded });
+    }
+  }
+  broadcastToFrontend(eventName, params);
+}
+
 const Network = {
   requestWillBeSent: (params) =>
     broadcastToFrontend("Network.requestWillBeSent", params),
@@ -256,8 +294,9 @@ const Network = {
     broadcastToFrontend("Network.loadingFinished", params),
   loadingFailed: (params) =>
     broadcastToFrontend("Network.loadingFailed", params),
-  dataReceived: (params) => broadcastToFrontend("Network.dataReceived", params),
-  dataSent: (params) => broadcastToFrontend("Network.dataSent", params),
+  dataReceived: (params) =>
+    broadcastNetworkData("Network.dataReceived", params),
+  dataSent: (params) => broadcastNetworkData("Network.dataSent", params),
   webSocketCreated: (params) =>
     broadcastToFrontend("Network.webSocketCreated", params),
   webSocketHandshakeResponseReceived: (params) =>

ext/node/polyfills/inspector.js

@@ -28,6 +28,7 @@ uv_compat_export = []
 [dependencies]
 anyhow.workspace = true
 az = "1.2.1"
+base64 = { workspace = true }
 bincode.workspace = true
 bit-set.workspace = true
 bit-vec.workspace = true