@react-native/dev-middleware 0.74.0 → 0.74.2

package/dist/inspector-proxy/Device.js

@@ -8,8 +8,8 @@ var _DeviceEventReporter = _interopRequireDefault(
   require("./DeviceEventReporter")
 );
 var fs = _interopRequireWildcard(require("fs"));
-var path = _interopRequireWildcard(require("path"));
 var _nodeFetch = _interopRequireDefault(require("node-fetch"));
+var path = _interopRequireWildcard(require("path"));
 var _ws = _interopRequireDefault(require("ws"));
 function _getRequireWildcardCache(nodeInterop) {
   if (typeof WeakMap !== "function") return null;
@@ -71,7 +71,7 @@ const PAGES_POLLING_INTERVAL = 1000;
 // Android's stock emulator and other emulators such as genymotion use a standard localhost alias.
 const EMULATOR_LOCALHOST_ADDRESSES = ["10.0.2.2", "10.0.3.2"];
 
-// Prefix for script URLs that are alphanumeric IDs. See comment in _processMessageFromDevice method for
+// Prefix for script URLs that are alphanumeric IDs. See comment in #processMessageFromDeviceLegacy method for
 // more details.
 const FILE_PREFIX = "file://";
 const REACT_NATIVE_RELOADABLE_PAGE_ID = "-1";
@@ -82,42 +82,49 @@ const REACT_NATIVE_RELOADABLE_PAGE_ID = "-1";
  */
 class Device {
   // ID of the device.
+  #id;
 
   // Name of the device.
+  #name;
 
   // Package name of the app.
+  #app;
 
   // Stores socket connection between Inspector Proxy and device.
+  #deviceSocket;
 
-  // Stores last list of device's pages.
+  // Stores the most recent listing of device's pages, keyed by the `id` field.
+  #pages;
 
   // Stores information about currently connected debugger (if any).
-  _debuggerConnection = null;
+  #debuggerConnection = null;
 
   // Last known Page ID of the React Native page.
   // This is used by debugger connections that don't have PageID specified
   // (and will interact with the latest React Native page).
-  _lastConnectedReactNativePage = null;
+  #lastConnectedLegacyReactNativePage = null;
 
   // Whether we are in the middle of a reload in the REACT_NATIVE_RELOADABLE_PAGE.
-  _isReloading = false;
+  #isLegacyPageReloading = false;
 
   // The previous "GetPages" message, for deduplication in debug logs.
-  _lastGetPagesMessage = "";
+  #lastGetPagesMessage = "";
 
   // Mapping built from scriptParsed events and used to fetch file content in `Debugger.getScriptSource`.
-  _scriptIdToSourcePathMapping = new Map();
+  #scriptIdToSourcePathMapping = new Map();
 
   // Root of the project used for relative to absolute source path conversion.
-
+  #projectRoot;
+  #deviceEventReporter;
+  #pagesPollingIntervalId;
   constructor(id, name, app, socket, projectRoot, eventReporter) {
-    this._id = id;
-    this._name = name;
-    this._app = app;
-    this._pages = [];
-    this._deviceSocket = socket;
-    this._projectRoot = projectRoot;
-    this._deviceEventReporter = eventReporter
+    this.#id = id;
+    this.#name = name;
+    this.#app = app;
+    this.#pages = new Map();
+    this.#deviceSocket = socket;
+    this.#projectRoot = projectRoot;
+    this.#deviceEventReporter = eventReporter
       ? new _DeviceEventReporter.default(eventReporter, {
           deviceId: id,
           deviceName: name,
@@ -126,49 +133,58 @@ class Device {
       : null;
 
     // $FlowFixMe[incompatible-call]
-    this._deviceSocket.on("message", (message) => {
+    this.#deviceSocket.on("message", (message) => {
       const parsedMessage = JSON.parse(message);
       if (parsedMessage.event === "getPages") {
         // There's a 'getPages' message every second, so only show them if they change
-        if (message !== this._lastGetPagesMessage) {
+        if (message !== this.#lastGetPagesMessage) {
           debug(
             "(Debugger)    (Proxy) <- (Device), getPages ping has changed: " +
               message
           );
-          this._lastGetPagesMessage = message;
+          this.#lastGetPagesMessage = message;
         }
       } else {
         debug("(Debugger)    (Proxy) <- (Device): " + message);
       }
-      this._handleMessageFromDevice(parsedMessage);
+      this.#handleMessageFromDevice(parsedMessage);
     });
-    this._deviceSocket.on("close", () => {
-      this._deviceEventReporter?.logDisconnection("device");
+    // Sends 'getPages' request to device every PAGES_POLLING_INTERVAL milliseconds.
+    this.#pagesPollingIntervalId = setInterval(
+      () =>
+        this.#sendMessageToDevice({
+          event: "getPages",
+        }),
+      PAGES_POLLING_INTERVAL
+    );
+    this.#deviceSocket.on("close", () => {
+      this.#deviceEventReporter?.logDisconnection("device");
       // Device disconnected - close debugger connection.
-      if (this._debuggerConnection) {
-        this._debuggerConnection.socket.close();
-        this._debuggerConnection = null;
+      if (this.#debuggerConnection) {
+        this.#debuggerConnection.socket.close();
+        this.#debuggerConnection = null;
       }
+      clearInterval(this.#pagesPollingIntervalId);
     });
-    this._setPagesPolling();
   }
   getName() {
-    return this._name;
+    return this.#name;
   }
   getApp() {
-    return this._app;
+    return this.#app;
   }
   getPagesList() {
-    if (this._lastConnectedReactNativePage) {
+    if (this.#lastConnectedLegacyReactNativePage) {
       const reactNativeReloadablePage = {
         id: REACT_NATIVE_RELOADABLE_PAGE_ID,
         title: "React Native Experimental (Improved Chrome Reloads)",
         vm: "don't use",
-        app: this._app,
+        app: this.#app,
+        capabilities: {},
       };
-      return this._pages.concat(reactNativeReloadablePage);
+      return [...this.#pages.values(), reactNativeReloadablePage];
     } else {
-      return this._pages;
+      return [...this.#pages.values()];
     }
   }
 
@@ -178,16 +194,16 @@ class Device {
   // 3. Sends disconnect event to device when debugger connection socket closes.
   handleDebuggerConnection(socket, pageId, metadata) {
     // Clear any commands we were waiting on.
-    this._deviceEventReporter?.logDisconnection("debugger");
-    this._deviceEventReporter?.logConnection("debugger", {
+    this.#deviceEventReporter?.logDisconnection("debugger");
+    this.#deviceEventReporter?.logConnection("debugger", {
       pageId,
       frontendUserAgent: metadata.userAgent,
     });
 
     // Disconnect current debugger if we already have debugger connected.
-    if (this._debuggerConnection) {
-      this._debuggerConnection.socket.close();
-      this._debuggerConnection = null;
+    if (this.#debuggerConnection) {
+      this.#debuggerConnection.socket.close();
+      this.#debuggerConnection = null;
     }
     const debuggerInfo = {
       socket,
@@ -195,12 +211,16 @@ class Device {
       pageId,
       userAgent: metadata.userAgent,
     };
-    this._debuggerConnection = debuggerInfo;
-    debug(`Got new debugger connection for page ${pageId} of ${this._name}`);
-    this._sendMessageToDevice({
+
+    // TODO(moti): Handle null case explicitly, e.g. refuse to connect to
+    // unknown pages.
+    const page = this.#pages.get(pageId);
+    this.#debuggerConnection = debuggerInfo;
+    debug(`Got new debugger connection for page ${pageId} of ${this.#name}`);
+    this.#sendMessageToDevice({
       event: "connect",
       payload: {
-        pageId: this._mapToDevicePageId(pageId),
+        pageId: this.#mapToDevicePageId(pageId),
       },
     });
 
@@ -208,35 +228,38 @@ class Device {
     socket.on("message", (message) => {
       debug("(Debugger) -> (Proxy)    (Device): " + message);
       const debuggerRequest = JSON.parse(message);
-      this._deviceEventReporter?.logRequest(debuggerRequest, "debugger", {
-        pageId: this._debuggerConnection?.pageId ?? null,
+      this.#deviceEventReporter?.logRequest(debuggerRequest, "debugger", {
+        pageId: this.#debuggerConnection?.pageId ?? null,
         frontendUserAgent: metadata.userAgent,
       });
-      const handled = this._interceptMessageFromDebugger(
-        debuggerRequest,
-        debuggerInfo,
-        socket
-      );
-      if (!handled) {
-        this._sendMessageToDevice({
+      let processedReq = debuggerRequest;
+      if (!page || !this.#pageHasCapability(page, "nativeSourceCodeFetching")) {
+        processedReq = this.#interceptClientMessageForSourceFetching(
+          debuggerRequest,
+          debuggerInfo,
+          socket
+        );
+      }
+      if (processedReq) {
+        this.#sendMessageToDevice({
           event: "wrappedEvent",
           payload: {
-            pageId: this._mapToDevicePageId(pageId),
-            wrappedEvent: JSON.stringify(debuggerRequest),
+            pageId: this.#mapToDevicePageId(pageId),
+            wrappedEvent: JSON.stringify(processedReq),
           },
         });
       }
     });
     socket.on("close", () => {
-      debug(`Debugger for page ${pageId} and ${this._name} disconnected.`);
-      this._deviceEventReporter?.logDisconnection("debugger");
-      this._sendMessageToDevice({
+      debug(`Debugger for page ${pageId} and ${this.#name} disconnected.`);
+      this.#deviceEventReporter?.logDisconnection("debugger");
+      this.#sendMessageToDevice({
         event: "disconnect",
         payload: {
-          pageId: this._mapToDevicePageId(pageId),
+          pageId: this.#mapToDevicePageId(pageId),
         },
       });
-      this._debuggerConnection = null;
+      this.#debuggerConnection = null;
     });
 
     // $FlowFixMe[method-unbinding]
@@ -259,17 +282,17 @@ class Device {
    */
   handleDuplicateDeviceConnection(newDevice) {
     if (
-      this._app !== newDevice.getApp() ||
-      this._name !== newDevice.getName()
+      this.#app !== newDevice.getApp() ||
+      this.#name !== newDevice.getName()
     ) {
-      this._deviceSocket.close();
-      this._debuggerConnection?.socket.close();
+      this.#deviceSocket.close();
+      this.#debuggerConnection?.socket.close();
     }
-    const oldDebugger = this._debuggerConnection;
-    this._debuggerConnection = null;
+    const oldDebugger = this.#debuggerConnection;
+    this.#debuggerConnection = null;
     if (oldDebugger) {
       oldDebugger.socket.removeAllListeners();
-      this._deviceSocket.close();
+      this.#deviceSocket.close();
       newDevice.handleDebuggerConnection(
         oldDebugger.socket,
         oldDebugger.pageId,
@@ -280,26 +303,60 @@ class Device {
     }
   }
 
+  /**
+   * Returns `true` if a page supports the given target capability flag.
+   */
+  #pageHasCapability(page, flag) {
+    return page.capabilities[flag] === true;
+  }
+
   // Handles messages received from device:
-  // 1. For getPages responses updates local _pages list.
+  // 1. For getPages responses updates local #pages list.
   // 2. All other messages are forwarded to debugger as wrappedEvent.
   //
   // In the future more logic will be added to this method for modifying
   // some of the messages (like updating messages with source maps and file
   // locations).
-  _handleMessageFromDevice(message) {
+  #handleMessageFromDevice(message) {
     if (message.event === "getPages") {
-      this._pages = message.payload;
+      this.#pages = new Map(
+        message.payload.map(({ capabilities, ...page }) => [
+          page.id,
+          {
+            ...page,
+            capabilities: capabilities ?? {},
+          },
+        ])
+      );
+      if (message.payload.length !== this.#pages.size) {
+        const duplicateIds = new Set();
+        const idsSeen = new Set();
+        for (const page of message.payload) {
+          if (!idsSeen.has(page.id)) {
+            idsSeen.add(page.id);
+          } else {
+            duplicateIds.add(page.id);
+          }
+        }
+        debug(
+          `Received duplicate page IDs from device: ${[...duplicateIds].join(
+            ", "
+          )}`
+        );
+      }
 
-      // Check if device have new React Native page.
+      // Check if device has a new legacy React Native page.
       // There is usually no more than 2-3 pages per device so this operation
       // is not expensive.
       // TODO(hypuk): It is better for VM to send update event when new page is
       // created instead of manually checking this on every getPages result.
-      for (let i = 0; i < this._pages.length; ++i) {
-        if (this._pages[i].title.indexOf("React") >= 0) {
-          if (this._pages[i].id !== this._lastConnectedReactNativePage?.id) {
-            this._newReactNativePage(this._pages[i]);
+      for (const page of this.#pages.values()) {
+        if (this.#pageHasCapability(page, "nativePageReloads")) {
+          continue;
+        }
+        if (page.title.includes("React")) {
+          if (page.id !== this.#lastConnectedLegacyReactNativePage?.id) {
+            this.#newLegacyReactNativePage(page);
             break;
           }
         }
@@ -308,15 +365,21 @@ class Device {
       // Device sends disconnect events only when page is reloaded or
       // if debugger socket was disconnected.
       const pageId = message.payload.pageId;
-      const debuggerSocket = this._debuggerConnection
-        ? this._debuggerConnection.socket
+      // TODO(moti): Handle null case explicitly, e.g. swallow disconnect events
+      // for unknown pages.
+      const page = this.#pages.get(pageId);
+      if (page != null && this.#pageHasCapability(page, "nativePageReloads")) {
+        return;
+      }
+      const debuggerSocket = this.#debuggerConnection
+        ? this.#debuggerConnection.socket
         : null;
       if (debuggerSocket && debuggerSocket.readyState === _ws.default.OPEN) {
         if (
-          this._debuggerConnection != null &&
-          this._debuggerConnection.pageId !== REACT_NATIVE_RELOADABLE_PAGE_ID
+          this.#debuggerConnection != null &&
+          this.#debuggerConnection.pageId !== REACT_NATIVE_RELOADABLE_PAGE_ID
         ) {
-          debug(`Page ${pageId} is reloading.`);
+          debug(`Legacy page ${pageId} is reloading.`);
           debuggerSocket.send(
             JSON.stringify({
               method: "reload",
@@ -325,14 +388,15 @@ class Device {
         }
       }
     } else if (message.event === "wrappedEvent") {
-      if (this._debuggerConnection == null) {
+      if (this.#debuggerConnection == null) {
         return;
       }
 
       // FIXME: Is it possible that we received message for pageID that does not
       // correspond to current debugger connection?
+      // TODO(moti): yes, fix multi-debugger case
 
-      const debuggerSocket = this._debuggerConnection.socket;
+      const debuggerSocket = this.#debuggerConnection.socket;
       if (
         debuggerSocket == null ||
         debuggerSocket.readyState !== _ws.default.OPEN
@@ -341,63 +405,56 @@ class Device {
         return;
       }
       const parsedPayload = JSON.parse(message.payload.wrappedEvent);
+      const pageId = this.#debuggerConnection?.pageId ?? null;
       if ("id" in parsedPayload) {
-        this._deviceEventReporter?.logResponse(parsedPayload, "device", {
-          pageId: this._debuggerConnection?.pageId ?? null,
-          frontendUserAgent: this._debuggerConnection?.userAgent ?? null,
+        this.#deviceEventReporter?.logResponse(parsedPayload, "device", {
+          pageId,
+          frontendUserAgent: this.#debuggerConnection?.userAgent ?? null,
         });
       }
-      if (this._debuggerConnection) {
+      if (this.#debuggerConnection != null) {
         // Wrapping just to make flow happy :)
         // $FlowFixMe[unused-promise]
-        this._processMessageFromDevice(
+        this.#processMessageFromDeviceLegacy(
           parsedPayload,
-          this._debuggerConnection
+          this.#debuggerConnection,
+          pageId
         ).then(() => {
           const messageToSend = JSON.stringify(parsedPayload);
           debuggerSocket.send(messageToSend);
         });
+      } else {
+        debuggerSocket.send(message.payload.wrappedEvent);
       }
     }
   }
 
   // Sends single message to device.
-  _sendMessageToDevice(message) {
+  #sendMessageToDevice(message) {
     try {
       if (message.event !== "getPages") {
         debug("(Debugger)    (Proxy) -> (Device): " + JSON.stringify(message));
       }
-      this._deviceSocket.send(JSON.stringify(message));
+      this.#deviceSocket.send(JSON.stringify(message));
     } catch (error) {}
   }
 
-  // Sends 'getPages' request to device every PAGES_POLLING_INTERVAL milliseconds.
-  _setPagesPolling() {
-    setInterval(
-      () =>
-        this._sendMessageToDevice({
-          event: "getPages",
-        }),
-      PAGES_POLLING_INTERVAL
-    );
-  }
-
   // We received new React Native Page ID.
-  _newReactNativePage(page) {
+  #newLegacyReactNativePage(page) {
     debug(`React Native page updated to ${page.id}`);
     if (
-      this._debuggerConnection == null ||
-      this._debuggerConnection.pageId !== REACT_NATIVE_RELOADABLE_PAGE_ID
+      this.#debuggerConnection == null ||
+      this.#debuggerConnection.pageId !== REACT_NATIVE_RELOADABLE_PAGE_ID
     ) {
       // We can just remember new page ID without any further actions if no
       // debugger is currently attached or attached debugger is not
       // "Reloadable React Native" connection.
-      this._lastConnectedReactNativePage = page;
+      this.#lastConnectedLegacyReactNativePage = page;
       return;
     }
-    const oldPageId = this._lastConnectedReactNativePage?.id;
-    this._lastConnectedReactNativePage = page;
-    this._isReloading = true;
+    const oldPageId = this.#lastConnectedLegacyReactNativePage?.id;
+    this.#lastConnectedLegacyReactNativePage = page;
+    this.#isLegacyPageReloading = true;
 
     // We already had a debugger connected to React Native page and a
     // new one appeared - in this case we need to emulate execution context
@@ -405,14 +462,14 @@ class Device {
     // page.
 
     if (oldPageId != null) {
-      this._sendMessageToDevice({
+      this.#sendMessageToDevice({
         event: "disconnect",
         payload: {
           pageId: oldPageId,
         },
       });
     }
-    this._sendMessageToDevice({
+    this.#sendMessageToDevice({
       event: "connect",
       payload: {
         pageId: page.id,
@@ -429,14 +486,14 @@ class Device {
       },
     ];
     for (const message of toSend) {
-      this._deviceEventReporter?.logRequest(message, "proxy", {
-        pageId: this._debuggerConnection?.pageId ?? null,
-        frontendUserAgent: this._debuggerConnection?.userAgent ?? null,
+      this.#deviceEventReporter?.logRequest(message, "proxy", {
+        pageId: this.#debuggerConnection?.pageId ?? null,
+        frontendUserAgent: this.#debuggerConnection?.userAgent ?? null,
       });
-      this._sendMessageToDevice({
+      this.#sendMessageToDevice({
         event: "wrappedEvent",
         payload: {
-          pageId: this._mapToDevicePageId(page.id),
+          pageId: this.#mapToDevicePageId(page.id),
           wrappedEvent: JSON.stringify(message),
         },
       });
@@ -444,14 +501,24 @@ class Device {
   }
 
   // Allows to make changes in incoming message from device.
-  async _processMessageFromDevice(payload, debuggerInfo) {
+  async #processMessageFromDeviceLegacy(payload, debuggerInfo, pageId) {
+    // TODO(moti): Handle null case explicitly, or ideally associate a copy
+    // of the page metadata object with the connection so this can never be
+    // null.
+    const page = pageId != null ? this.#pages.get(pageId) : null;
+
     // Replace Android addresses for scriptParsed event.
-    if (payload.method === "Debugger.scriptParsed") {
-      const params = payload.params || {};
+    if (
+      (!page || !this.#pageHasCapability(page, "nativeSourceCodeFetching")) &&
+      payload.method === "Debugger.scriptParsed" &&
+      payload.params != null
+    ) {
+      const params = payload.params;
       if ("sourceMapURL" in params) {
         for (let i = 0; i < EMULATOR_LOCALHOST_ADDRESSES.length; ++i) {
           const address = EMULATOR_LOCALHOST_ADDRESSES[i];
-          if (params.sourceMapURL.indexOf(address) >= 0) {
+          if (params.sourceMapURL.includes(address)) {
+            // $FlowFixMe[cannot-write]
             payload.params.sourceMapURL = params.sourceMapURL.replace(
               address,
               "localhost"
@@ -459,7 +526,7 @@ class Device {
             debuggerInfo.originalSourceURLAddress = address;
           }
         }
-        const sourceMapURL = this._tryParseHTTPURL(params.sourceMapURL);
+        const sourceMapURL = this.#tryParseHTTPURL(params.sourceMapURL);
         if (sourceMapURL) {
           // Some debug clients do not support fetching HTTP URLs. If the
           // message headed to the debug client identifies the source map with
@@ -467,12 +534,13 @@ class Device {
           // Data URL (which is more widely supported) before passing the
           // message to the debug client.
           try {
-            const sourceMap = await this._fetchText(sourceMapURL);
+            const sourceMap = await this.#fetchText(sourceMapURL);
+            // $FlowFixMe[cannot-write]
             payload.params.sourceMapURL =
               "data:application/json;charset=utf-8;base64," +
               new Buffer(sourceMap).toString("base64");
           } catch (exception) {
-            this._sendErrorToDebugger(
+            this.#sendErrorToDebugger(
               `Failed to fetch source map ${params.sourceMapURL}: ${exception.message}`
             );
           }
@@ -482,6 +550,7 @@ class Device {
         for (let i = 0; i < EMULATOR_LOCALHOST_ADDRESSES.length; ++i) {
           const address = EMULATOR_LOCALHOST_ADDRESSES[i];
           if (params.url.indexOf(address) >= 0) {
+            // $FlowFixMe[cannot-write]
             payload.params.url = params.url.replace(address, "localhost");
             debuggerInfo.originalSourceURLAddress = address;
           }
@@ -492,19 +561,20 @@ class Device {
         // Chrome to not download source maps. In this case we want to prepend script ID
         // with 'file://' prefix.
         if (payload.params.url.match(/^[0-9a-z]+$/)) {
+          // $FlowFixMe[cannot-write]
           payload.params.url = FILE_PREFIX + payload.params.url;
           debuggerInfo.prependedFilePrefix = true;
         }
 
         // $FlowFixMe[prop-missing]
         if (params.scriptId != null) {
-          this._scriptIdToSourcePathMapping.set(params.scriptId, params.url);
+          this.#scriptIdToSourcePathMapping.set(params.scriptId, params.url);
         }
       }
     }
     if (
       payload.method === "Runtime.executionContextCreated" &&
-      this._isReloading
+      this.#isLegacyPageReloading
     ) {
       // The new context is ready. First notify Chrome that we've reloaded so
       // it'll resend its breakpoints. If we do this earlier, we may not be
@@ -526,61 +596,76 @@ class Device {
         method: "Debugger.resume",
         id: 0,
       };
-      this._deviceEventReporter?.logRequest(resumeMessage, "proxy", {
-        pageId: this._debuggerConnection?.pageId ?? null,
-        frontendUserAgent: this._debuggerConnection?.userAgent ?? null,
+      this.#deviceEventReporter?.logRequest(resumeMessage, "proxy", {
+        pageId: this.#debuggerConnection?.pageId ?? null,
+        frontendUserAgent: this.#debuggerConnection?.userAgent ?? null,
       });
-      this._sendMessageToDevice({
+      this.#sendMessageToDevice({
         event: "wrappedEvent",
         payload: {
-          pageId: this._mapToDevicePageId(debuggerInfo.pageId),
+          pageId: this.#mapToDevicePageId(debuggerInfo.pageId),
           wrappedEvent: JSON.stringify(resumeMessage),
         },
       });
-      this._isReloading = false;
+      this.#isLegacyPageReloading = false;
     }
   }
 
-  // Allows to make changes in incoming messages from debugger. Returns a boolean
-  // indicating whether the message has been handled locally (i.e. does not need
-  // to be forwarded to the target).
-  _interceptMessageFromDebugger(req, debuggerInfo, socket) {
-    if (req.method === "Debugger.setBreakpointByUrl") {
-      this._processDebuggerSetBreakpointByUrl(req, debuggerInfo);
-    } else if (req.method === "Debugger.getScriptSource") {
-      this._processDebuggerGetScriptSource(req, socket);
-      return true;
+  /**
+   * Intercept an incoming message from a connected debugger. Returns either an
+   * original/replacement CDP message object, or `null` (will forward nothing
+   * to the target).
+   */
+  #interceptClientMessageForSourceFetching(req, debuggerInfo, socket) {
+    switch (req.method) {
+      case "Debugger.setBreakpointByUrl":
+        return this.#processDebuggerSetBreakpointByUrl(req, debuggerInfo);
+      case "Debugger.getScriptSource":
+        // Sends response to debugger via side-effect
+        this.#processDebuggerGetScriptSource(req, socket);
+        return null;
+      default:
+        return req;
     }
-    return false;
   }
-  _processDebuggerSetBreakpointByUrl(req, debuggerInfo) {
+  #processDebuggerSetBreakpointByUrl(req, debuggerInfo) {
     // If we replaced Android emulator's address to localhost we need to change it back.
     if (debuggerInfo.originalSourceURLAddress != null) {
-      if (req.params.url != null) {
-        req.params.url = req.params.url.replace(
+      const processedReq = {
+        ...req,
+        params: {
+          ...req.params,
+        },
+      };
+      if (processedReq.params.url != null) {
+        processedReq.params.url = processedReq.params.url.replace(
           "localhost",
           debuggerInfo.originalSourceURLAddress
         );
         if (
-          req.params.url &&
-          req.params.url.startsWith(FILE_PREFIX) &&
+          processedReq.params.url &&
+          processedReq.params.url.startsWith(FILE_PREFIX) &&
           debuggerInfo.prependedFilePrefix
         ) {
-          // Remove fake URL prefix if we modified URL in _processMessageFromDevice.
+          // Remove fake URL prefix if we modified URL in #processMessageFromDeviceLegacy.
           // $FlowFixMe[incompatible-use]
-          req.params.url = req.params.url.slice(FILE_PREFIX.length);
+          processedReq.params.url = processedReq.params.url.slice(
+            FILE_PREFIX.length
+          );
         }
       }
-      if (req.params.urlRegex != null) {
-        req.params.urlRegex = req.params.urlRegex.replace(
+      if (processedReq.params.urlRegex != null) {
+        processedReq.params.urlRegex = processedReq.params.urlRegex.replace(
           /localhost/g,
           // $FlowFixMe[incompatible-call]
           debuggerInfo.originalSourceURLAddress
         );
       }
+      return processedReq;
     }
+    return req;
   }
-  _processDebuggerGetScriptSource(req, socket) {
+  #processDebuggerGetScriptSource(req, socket) {
     const sendSuccessResponse = (scriptSource) => {
       const response = {
         id: req.id,
@@ -589,9 +674,9 @@ class Device {
         },
       };
       socket.send(JSON.stringify(response));
-      this._deviceEventReporter?.logResponse(response, "proxy", {
-        pageId: this._debuggerConnection?.pageId ?? null,
-        frontendUserAgent: this._debuggerConnection?.userAgent ?? null,
+      this.#deviceEventReporter?.logResponse(response, "proxy", {
+        pageId: this.#debuggerConnection?.pageId ?? null,
+        frontendUserAgent: this.#debuggerConnection?.userAgent ?? null,
       });
     };
     const sendErrorResponse = (error) => {
@@ -608,19 +693,19 @@ class Device {
       socket.send(JSON.stringify(response));
 
       // Send to the console as well, so the user can see it
-      this._sendErrorToDebugger(error);
-      this._deviceEventReporter?.logResponse(response, "proxy", {
-        pageId: this._debuggerConnection?.pageId ?? null,
-        frontendUserAgent: this._debuggerConnection?.userAgent ?? null,
+      this.#sendErrorToDebugger(error);
+      this.#deviceEventReporter?.logResponse(response, "proxy", {
+        pageId: this.#debuggerConnection?.pageId ?? null,
+        frontendUserAgent: this.#debuggerConnection?.userAgent ?? null,
       });
     };
-    const pathToSource = this._scriptIdToSourcePathMapping.get(
+    const pathToSource = this.#scriptIdToSourcePathMapping.get(
       req.params.scriptId
     );
     if (pathToSource != null) {
-      const httpURL = this._tryParseHTTPURL(pathToSource);
+      const httpURL = this.#tryParseHTTPURL(pathToSource);
       if (httpURL) {
-        this._fetchText(httpURL).then(
+        this.#fetchText(httpURL).then(
           (text) => sendSuccessResponse(text),
           (err) =>
             sendErrorResponse(
@@ -631,7 +716,7 @@ class Device {
         let file;
         try {
           file = fs.readFileSync(
-            path.resolve(this._projectRoot, pathToSource),
+            path.resolve(this.#projectRoot, pathToSource),
             "utf8"
           );
         } catch (err) {
@@ -645,17 +730,17 @@ class Device {
       }
     }
   }
-  _mapToDevicePageId(pageId) {
+  #mapToDevicePageId(pageId) {
     if (
       pageId === REACT_NATIVE_RELOADABLE_PAGE_ID &&
-      this._lastConnectedReactNativePage != null
+      this.#lastConnectedLegacyReactNativePage != null
     ) {
-      return this._lastConnectedReactNativePage.id;
+      return this.#lastConnectedLegacyReactNativePage.id;
     } else {
       return pageId;
     }
   }
-  _tryParseHTTPURL(url) {
+  #tryParseHTTPURL(url) {
     let parsedURL;
     try {
       parsedURL = new URL(url);
@@ -669,13 +754,16 @@ class Device {
 
   // Fetch text, raising an exception if the text could not be fetched,
   // or is too large.
-  async _fetchText(url) {
-    if (url.hostname !== "localhost") {
+  async #fetchText(url) {
+    if (!["localhost", "127.0.0.1"].includes(url.hostname)) {
       throw new Error("remote fetches not permitted");
     }
 
     // $FlowFixMe[incompatible-call] Suppress arvr node-fetch flow error
     const response = await (0, _nodeFetch.default)(url);
+    if (!response.ok) {
+      throw new Error("HTTP " + response.status + " " + response.statusText);
+    }
     const text = await response.text();
     // Restrict the length to well below the 500MB limit for nodejs (leaving
     // room some some later manipulation, e.g. base64 or wrapping in JSON)
@@ -684,8 +772,8 @@ class Device {
     }
     return text;
   }
-  _sendErrorToDebugger(message) {
-    const debuggerSocket = this._debuggerConnection?.socket;
+  #sendErrorToDebugger(message) {
+    const debuggerSocket = this.#debuggerConnection?.socket;
     if (debuggerSocket && debuggerSocket.readyState === _ws.default.OPEN) {
       debuggerSocket.send(
         JSON.stringify({