expo-dev-launcher 2.1.5 → 2.2.0

package/CHANGELOG.md

@@ -10,6 +10,24 @@
 
 ### 💡 Others
 
+## 2.2.0 — 2023-04-13
+
+### 🎉 New features
+
+- Added experimental network inspector. ([#21265](https://github.com/expo/expo/pull/21265), [#21327](https://github.com/expo/expo/pull/21327) by [@kudo](https://github.com/kudo))
+
+### 🐛 Bug fixes
+
+- Add missing `mimeType` when emitting network responses. ([#21676](https://github.com/expo/expo/pull/21676) by [@byCedric](https://github.com/byCedric))
+- Add missing `Network.requestWillBeSentExtraInfo` when emitting network requests. ([#21965](https://github.com/expo/expo/pull/21965) by [@byCedric](https://github.com/byCedric))
+- Don't require legacy manifest signature in dev clients. ([#21970](https://github.com/expo/expo/pull/21970) by [@wschurman](https://github.com/wschurman))
+
+## 2.1.6 — 2023-03-20
+
+### 🐛 Bug fixes
+
+- Change arg in gradle `.execute()` call to null to inherit env variables from user's env ([#21712](https://github.com/expo/expo/pull/21712) by [@phoenixiguess](https://github.com/phoenixiguess))
+
 ## 2.1.5 — 2023-03-03
 
 ### 💡 Others

package/android/build.gradle

@@ -40,7 +40,7 @@ android {
     minSdkVersion safeExtGet('minSdkVersion', 21)
     targetSdkVersion safeExtGet("targetSdkVersion", 33)
     versionCode 9
-    versionName "2.1.5"
+    versionName "2.2.0"
   }
 
   lintOptions {
@@ -180,7 +180,7 @@ def versionToNumber(major, minor, patch) {
 }
 
 def getNodeModulesPackageVersion(packageName, overridePropName) {
-  def nodeModulesVersion = ["node", "-e", "console.log(require('$packageName/package.json').version);"].execute([], projectDir).text.trim()
+  def nodeModulesVersion = ["node", "-e", "console.log(require('$packageName/package.json').version);"].execute(null, projectDir).text.trim()
   def version = safeExtGet(overridePropName, nodeModulesVersion)
 
   def coreVersion = version.split("-")[0]

package/android/src/main/java/expo/modules/devlauncher/helpers/DevLauncherUpdatesHelper.kt

@@ -59,6 +59,7 @@ fun createUpdatesConfigurationWithUrl(url: Uri, projectUrl: Uri, installationID:
     "launchWaitMs" to 60000,
     "checkOnLaunch" to "ALWAYS",
     "enabled" to true,
-    "requestHeaders" to requestHeaders
+    "requestHeaders" to requestHeaders,
+    "expectsSignedManifest" to false,
   )
 }

package/android/src/main/java/expo/modules/devlauncher/network/DevLauncherNetworkLogger.kt

@@ -0,0 +1,232 @@
+package expo.modules.devlauncher.network
+
+import androidx.collection.ArrayMap
+import com.facebook.react.ReactInstanceManager
+import com.facebook.react.bridge.Inspector
+import com.facebook.react.common.LifecycleState
+import com.facebook.react.devsupport.DevServerHelper
+import com.facebook.react.devsupport.InspectorPackagerConnection
+import expo.modules.devlauncher.DevLauncherController
+import okhttp3.Headers
+import okhttp3.Request
+import okhttp3.Response
+import okio.Buffer
+import org.json.JSONObject
+import java.lang.ref.WeakReference
+import java.lang.reflect.Field
+import java.lang.reflect.Method
+import java.math.BigDecimal
+import java.math.RoundingMode
+
+class DevLauncherNetworkLogger private constructor() {
+  private var reactInstanceHashCode: Int = 0
+  private var _inspectorPackagerConnection: InspectorPackagerConnectionWrapper? = null
+
+  private val inspectorPackagerConnection: InspectorPackagerConnectionWrapper
+    get() {
+      val reactInstanceManager = DevLauncherController.instance.appHost.reactInstanceManager
+      if (reactInstanceHashCode != reactInstanceManager.hashCode()) {
+        _inspectorPackagerConnection?.clear()
+        _inspectorPackagerConnection = null
+        reactInstanceHashCode = 0
+      }
+      if (_inspectorPackagerConnection == null) {
+        _inspectorPackagerConnection = InspectorPackagerConnectionWrapper(reactInstanceManager)
+        reactInstanceHashCode = reactInstanceManager.hashCode()
+      }
+      return requireNotNull(_inspectorPackagerConnection)
+    }
+
+  /**
+   * Returns true when it is allowed to send CDP events
+   */
+  fun shouldEmitEvents(): Boolean {
+    return DevLauncherController.wasInitialized() && DevLauncherController.instance.appHost.reactInstanceManager.lifecycleState == LifecycleState.RESUMED
+  }
+
+  /**
+   * Emits CDP `Network.requestWillBeSent` and `Network.requestWillBeSentExtraInfo` events
+   */
+  fun emitNetworkWillBeSent(request: Request, requestId: String, redirectResponse: Response?) {
+    val now = BigDecimal(System.currentTimeMillis() / 1000.0).setScale(3, RoundingMode.CEILING)
+    val requestParams = buildMap<String, Any> {
+      put("url", request.url().toString())
+      put("method", request.method())
+      put("headers", request.headers().toSingleMap())
+      val body = request.body()
+      if (body != null && body.contentLength() < MAX_BODY_SIZE) {
+        val buffer = Buffer()
+        body.writeTo(buffer)
+        put("postData", buffer.readUtf8(buffer.size.coerceAtMost(MAX_BODY_SIZE)))
+      }
+    }
+    val requestWillBeSentParams = buildMap<String, Any> {
+      put("requestId", requestId)
+      put("loaderId", "")
+      put("documentURL", "mobile")
+      put("initiator", mapOf("type" to "script"))
+      put("redirectHasExtraInfo", redirectResponse != null)
+      put("request", requestParams)
+      put("referrerPolicy", "no-referrer")
+      put("type", "Fetch")
+      put("timestamp", now)
+      put("wallTime", now)
+      if (redirectResponse != null) {
+        put("redirectResponse", mapOf(
+          "url" to redirectResponse.request().url().toString(),
+          "status" to redirectResponse.code(),
+          "statusText" to redirectResponse.message(),
+          "headers" to redirectResponse.headers().toSingleMap(),
+        ))
+      }
+    }
+    val requestWillBeSentData = JSONObject(mapOf(
+      "method" to "Network.requestWillBeSent",
+      "params" to requestWillBeSentParams,
+    ))
+    inspectorPackagerConnection.sendWrappedEventToAllPages(requestWillBeSentData.toString())
+
+    val extraInfoParams = mapOf(
+      "requestId" to requestId,
+      "associatedCookies" to emptyList<Void>(),
+      "headers" to request.headers().toSingleMap(),
+      "connectTiming" to mapOf(
+        "requestTime" to now,
+      ),
+    )
+    val extraInfoData = JSONObject(mapOf(
+      "method" to "Network.requestWillBeSentExtraInfo",
+      "params" to extraInfoParams
+    ))
+    inspectorPackagerConnection.sendWrappedEventToAllPages(extraInfoData.toString())
+  }
+
+  /**
+   * Emits CDP `Network.responseReceived` and `Network.loadingFinished` events
+   */
+  fun emitNetworkResponse(request: Request, requestId: String, response: Response) {
+    val now = BigDecimal(System.currentTimeMillis() / 1000.0).setScale(3, RoundingMode.CEILING)
+    val responseReceivedParams = mapOf(
+      "requestId" to requestId,
+      "loaderId" to "",
+      "hasExtraInfo" to false,
+      "response" to mapOf(
+        "url" to request.url().toString(),
+        "status" to response.code(),
+        "statusText" to response.message(),
+        "headers" to response.headers().toSingleMap(),
+        "mimeType" to response.header("Content-Type", ""),
+      ),
+      "referrerPolicy" to "no-referrer",
+      "type" to "Fetch",
+      "timestamp" to now,
+    )
+    val responseReceivedData = JSONObject(mapOf(
+      "method" to "Network.responseReceived",
+      "params" to responseReceivedParams,
+    ))
+    inspectorPackagerConnection.sendWrappedEventToAllPages(responseReceivedData.toString())
+
+    val loadingFinishedParams = mapOf(
+      "requestId" to requestId,
+      "timestamp" to now,
+      "encodedDataLength" to (response.body()?.contentLength() ?: 0),
+    )
+    val loadingFinishedData = JSONObject(mapOf(
+      "method" to "Network.loadingFinished",
+      "params" to loadingFinishedParams,
+    ))
+    inspectorPackagerConnection.sendWrappedEventToAllPages(loadingFinishedData.toString())
+  }
+
+  /**
+   * Emits our custom `Expo(Network.receivedResponseBody)` event
+   */
+  fun emitNetworkDidReceiveBody(requestId: String, response: Response) {
+    val contentLength = response.body()?.contentLength() ?: 0
+    if (contentLength <= 0 || contentLength > MAX_BODY_SIZE) {
+      return
+    }
+    val body = response.peekBody(MAX_BODY_SIZE)
+    val contentType = body.contentType()
+    val isText = contentType?.type() == "text" || (contentType?.type() == "application" && contentType?.subtype() == "json")
+    val bodyString = if (isText) body.string() else body.source().readByteString().base64()
+    val params = mapOf(
+      "requestId" to requestId,
+      "body" to bodyString,
+      "base64Encoded" to !isText,
+    )
+    val data = JSONObject(mapOf(
+      "method" to "Expo(Network.receivedResponseBody)",
+      "params" to params,
+    ))
+    inspectorPackagerConnection.sendWrappedEventToAllPages(data.toString())
+  }
+
+  companion object {
+    val instance = DevLauncherNetworkLogger()
+    private const val MAX_BODY_SIZE = 1048576L
+  }
+}
+
+/**
+ * A `InspectorPackagerConnection` wrapper to expose private members with reflection
+ */
+internal class InspectorPackagerConnectionWrapper constructor(reactInstanceManager: ReactInstanceManager) {
+  private var inspectorPackagerConnectionWeak: WeakReference<InspectorPackagerConnection> = WeakReference(null)
+  private val devServerHelperWeak: WeakReference<DevServerHelper>
+  private val inspectorPackagerConnectionField: Field
+  private val sendWrappedEventMethod: Method
+
+  private val inspectorPackagerConnection: InspectorPackagerConnection?
+    get() {
+      var inspectorPackagerConnection = inspectorPackagerConnectionWeak.get()
+      if (inspectorPackagerConnection == null) {
+        val devServerHelper = devServerHelperWeak.get() ?: return null
+        inspectorPackagerConnection = inspectorPackagerConnectionField[devServerHelper] as? InspectorPackagerConnection
+
+        if (inspectorPackagerConnection != null) {
+          inspectorPackagerConnectionWeak = WeakReference(inspectorPackagerConnection)
+        }
+      }
+      return inspectorPackagerConnection
+    }
+
+  init {
+    val devSupportManager = reactInstanceManager.devSupportManager
+    val devSupportManagerBaseClass: Class<*> = devSupportManager.javaClass.superclass
+    val mDevServerHelperField = devSupportManagerBaseClass.getDeclaredField("mDevServerHelper")
+    mDevServerHelperField.isAccessible = true
+    val devServerHelper = mDevServerHelperField[devSupportManager]
+    devServerHelperWeak = WeakReference(devServerHelper as DevServerHelper)
+
+    inspectorPackagerConnectionField = DevServerHelper::class.java.getDeclaredField("mInspectorPackagerConnection")
+    inspectorPackagerConnectionField.isAccessible = true
+
+    sendWrappedEventMethod = InspectorPackagerConnection::class.java.getDeclaredMethod("sendWrappedEvent", String::class.java, String::class.java)
+    sendWrappedEventMethod.isAccessible = true
+  }
+
+  fun clear() {
+    inspectorPackagerConnectionWeak.clear()
+  }
+
+  fun sendWrappedEventToAllPages(event: String) {
+    val inspectorPackagerConnection = this.inspectorPackagerConnection ?: return
+    for (page in Inspector.getPages()) {
+      sendWrappedEventMethod.invoke(inspectorPackagerConnection, page.id.toString(), event)
+    }
+  }
+}
+
+/**
+ * OkHttp `Headers` extension method to generate a simple key-value map
+ * which only exposing single value for a key.
+ */
+fun Headers.toSingleMap(): Map<String, String> {
+  val result = ArrayMap<String, String>()
+  for (key in names()) {
+    result[key] = get(key)
+  }
+  return result
+}

package/android/src/main/java/expo/modules/devlauncher/network/DevLauncherOkHttpInterceptors.kt

@@ -0,0 +1,57 @@
+package expo.modules.devlauncher.network
+
+import okhttp3.Interceptor
+import okhttp3.Response
+
+/**
+ * The OkHttp network interceptor to log requests and the CDP events to [DevLauncherNetworkLogger]
+ */
+@Suppress("unused")
+class DevLauncherOkHttpNetworkInterceptor : Interceptor {
+  override fun intercept(chain: Interceptor.Chain): Response {
+    if (!DevLauncherNetworkLogger.instance.shouldEmitEvents()) {
+      return chain.proceed(chain.request());
+    }
+    val request = chain.request()
+    val redirectResponse = request.tag(RedirectResponse::class.java)
+    val requestId = redirectResponse?.requestId ?: request.hashCode().toString()
+    DevLauncherNetworkLogger.instance.emitNetworkWillBeSent(request, requestId, redirectResponse?.priorResponse)
+
+    val response = chain.proceed(request)
+
+    if (response.isRedirect) {
+      response.request().tag(RedirectResponse::class.java)?.let {
+        it.requestId = requestId
+        it.priorResponse = response
+      }
+    } else {
+      DevLauncherNetworkLogger.instance.emitNetworkResponse(request, requestId, response)
+      DevLauncherNetworkLogger.instance.emitNetworkDidReceiveBody(requestId, response)
+    }
+    return response
+  }
+}
+
+/**
+ * The OkHttp app interceptor to add custom tag for [RedirectResponse]
+ */
+@Suppress("unused")
+class DevLauncherOkHttpAppInterceptor : Interceptor {
+  override fun intercept(chain: Interceptor.Chain): Response {
+    if (!DevLauncherNetworkLogger.instance.shouldEmitEvents()) {
+      return chain.proceed(chain.request());
+    }
+    return chain.proceed(chain.request().newBuilder()
+      .tag(RedirectResponse::class.java, RedirectResponse())
+      .build()
+    )
+  }
+}
+
+/**
+ * Custom property for redirect requests
+ */
+internal class RedirectResponse {
+  var requestId: String? = null
+  var priorResponse: Response? = null
+}

package/expo-dev-launcher-gradle-plugin/build.gradle.kts

@@ -0,0 +1,38 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+  kotlin("jvm") version "1.8.10"
+  id("java-gradle-plugin")
+}
+
+repositories {
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  implementation(gradleApi())
+  implementation("com.android.tools.build:gradle:7.3.1")
+}
+
+java {
+  sourceCompatibility = JavaVersion.VERSION_11
+  targetCompatibility = JavaVersion.VERSION_11
+}
+
+tasks.withType<KotlinCompile> {
+  kotlinOptions {
+    jvmTarget = JavaVersion.VERSION_11.toString()
+  }
+}
+
+group = "expo.modules"
+
+gradlePlugin {
+  plugins {
+    register("expoDevLauncherPlugin") {
+      id = "expo-dev-launcher-gradle-plugin"
+      implementationClass = "expo.modules.devlauncher.DevLauncherPlugin"
+    }
+  }
+}

package/expo-dev-launcher-gradle-plugin/src/main/kotlin/expo/modules/devlauncher/DevLauncherPlugin.kt

@@ -0,0 +1,101 @@
+package expo.modules.devlauncher
+
+import com.android.build.api.instrumentation.AsmClassVisitorFactory
+import com.android.build.api.instrumentation.ClassContext
+import com.android.build.api.instrumentation.ClassData
+import com.android.build.api.instrumentation.FramesComputationMode
+import com.android.build.api.instrumentation.InstrumentationParameters
+import com.android.build.api.instrumentation.InstrumentationScope
+import com.android.build.api.variant.AndroidComponentsExtension
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Optional
+import org.objectweb.asm.ClassVisitor
+import org.objectweb.asm.MethodVisitor
+import org.objectweb.asm.Opcodes
+import org.slf4j.LoggerFactory
+
+abstract class DevLauncherPlugin : Plugin<Project> {
+
+  override fun apply(project: Project) {
+    val enableNetworkInspector = project.properties["EX_DEV_CLIENT_NETWORK_INSPECTOR"]?.toString()?.toBoolean()
+    if (enableNetworkInspector != null && enableNetworkInspector) {
+      val androidComponents = project.extensions.getByType(AndroidComponentsExtension::class.java)
+      androidComponents.onVariants(androidComponents.selector().withBuildType("debug")) { variant ->
+        variant.instrumentation.transformClassesWith(DevLauncherClassVisitorFactory::class.java, InstrumentationScope.ALL) {
+        }
+        variant.instrumentation.setAsmFramesComputationMode(FramesComputationMode.COMPUTE_FRAMES_FOR_INSTRUMENTED_METHODS)
+      }
+    }
+  }
+
+  interface DevLauncherPluginParameters : InstrumentationParameters {
+    @get:Input
+    @get:Optional
+    val enabled: Property<Boolean>
+  }
+
+  abstract class DevLauncherClassVisitorFactory : AsmClassVisitorFactory<DevLauncherPluginParameters> {
+    override fun createClassVisitor(
+      classContext: ClassContext,
+      nextClassVisitor: ClassVisitor
+    ): ClassVisitor {
+      if (parameters.get().enabled.getOrElse(false)) {
+        return nextClassVisitor
+      }
+      return OkHttpClassVisitor(classContext, instrumentationContext.apiVersion.get(), nextClassVisitor)
+    }
+
+    override fun isInstrumentable(classData: ClassData): Boolean {
+      if (parameters.get().enabled.getOrElse(false)) {
+        return false
+      }
+      return classData.className in listOf("okhttp3.OkHttpClient\$Builder")
+    }
+  }
+
+  class OkHttpClassVisitor(private val classContext: ClassContext, api: Int, classVisitor: ClassVisitor) : ClassVisitor(api, classVisitor) {
+    override fun visitMethod(access: Int, name: String?, descriptor: String?, signature: String?, exceptions: Array<out String>?): MethodVisitor {
+      val originalVisitor = super.visitMethod(access, name, descriptor, signature, exceptions)
+      if (name == "build") {
+        return OkHttpClientCustomBuildMethod(api, originalVisitor)
+      }
+      return originalVisitor
+    }
+  }
+
+  class OkHttpClientCustomBuildMethod(api: Int, methodVisitor: MethodVisitor) : MethodVisitor(api, methodVisitor) {
+    override fun visitCode() {
+      // opcodes for `this.addInterceptor(expo.modules.devlauncher.network.DevLauncherOkHttpAppInterceptor())`
+      visitVarInsn(Opcodes.ALOAD, 0)
+      visitTypeInsn(Opcodes.NEW, "expo/modules/devlauncher/network/DevLauncherOkHttpAppInterceptor")
+      visitInsn(Opcodes.DUP)
+      visitMethodInsn(Opcodes.INVOKESPECIAL, "expo/modules/devlauncher/network/DevLauncherOkHttpAppInterceptor", "<init>", "()V", false)
+      visitTypeInsn(Opcodes.CHECKCAST, "okhttp3/Interceptor")
+      visitMethodInsn(Opcodes.INVOKEVIRTUAL, "okhttp3/OkHttpClient\$Builder", "addInterceptor", "(Lokhttp3/Interceptor;)Lokhttp3/OkHttpClient\$Builder;", false)
+
+      // opcodes for `this.addNetworkInterceptor(expo.modules.devlauncher.network.DevLauncherOkHttpNetworkInterceptor())`
+      visitVarInsn(Opcodes.ALOAD, 0)
+      visitTypeInsn(Opcodes.NEW, "expo/modules/devlauncher/network/DevLauncherOkHttpNetworkInterceptor")
+      visitInsn(Opcodes.DUP)
+      visitMethodInsn(Opcodes.INVOKESPECIAL, "expo/modules/devlauncher/network/DevLauncherOkHttpNetworkInterceptor", "<init>", "()V", false)
+      visitTypeInsn(Opcodes.CHECKCAST, "okhttp3/Interceptor")
+      visitMethodInsn(Opcodes.INVOKEVIRTUAL, "okhttp3/OkHttpClient\$Builder", "addNetworkInterceptor", "(Lokhttp3/Interceptor;)Lokhttp3/OkHttpClient\$Builder;", false)
+
+      // opcodes for `return OkHttpClient(this)`
+      visitTypeInsn(Opcodes.NEW, "okhttp3/OkHttpClient")
+      visitInsn(Opcodes.DUP)
+      visitVarInsn(Opcodes.ALOAD, 0)
+      visitMethodInsn(Opcodes.INVOKESPECIAL, "okhttp3/OkHttpClient", "<init>", "(Lokhttp3/OkHttpClient\$Builder;)V", false)
+      visitInsn(Opcodes.ARETURN)
+    }
+  }
+
+  companion object {
+    internal val logger by lazy {
+      LoggerFactory.getLogger(DevLauncherPlugin::class.java)
+    }
+  }
+}

package/expo-dev-launcher.podspec

@@ -32,17 +32,24 @@ Pod::Spec.new do |s|
     'GCC_PREPROCESSOR_DEFINITIONS' => "EX_DEV_LAUNCHER_VERSION=#{s.version}"
   }
 
-  # Swift/Objective-C compatibility
-  s.pod_target_xcconfig = { "DEFINES_MODULE" => "YES" }
+  other_c_flags = '$(inherited)'
   dev_launcher_url = ENV['EX_DEV_LAUNCHER_URL'] || ""
   if dev_launcher_url != ""
     escaped_dev_launcher_url = Shellwords.escape(dev_launcher_url).gsub('/','\\/')
-    s.pod_target_xcconfig = {
-      'DEFINES_MODULE' => 'YES',
-      'OTHER_CFLAGS[config=Debug]' => "$(inherited) -DEX_DEV_LAUNCHER_URL=\"\\\"" + escaped_dev_launcher_url + "\\\"\""
-    }
+    other_c_flags += " -DEX_DEV_LAUNCHER_URL=\"\\\"" + escaped_dev_launcher_url + "\\\"\""
+  end
+  other_swift_flags = "$(inherited)"
+  if ENV['EX_DEV_CLIENT_NETWORK_INSPECTOR'] == '1'
+    other_swift_flags += ' -DEX_DEV_CLIENT_NETWORK_INSPECTOR'
   end
 
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'OTHER_CFLAGS[config=Debug]' => other_c_flags,
+    'OTHER_SWIFT_FLAGS[config=Debug]' => other_swift_flags,
+  }
+
   s.user_target_xcconfig = {
     "HEADER_SEARCH_PATHS" => "\"${PODS_CONFIGURATION_BUILD_DIR}/expo-dev-launcher/Swift Compatibility Header\"",
   }

package/expo-module.config.json

@@ -7,5 +7,14 @@
     "appDelegateSubscribers": ["ExpoDevLauncherAppDelegateSubscriber"],
     "reactDelegateHandlers": ["ExpoDevLauncherReactDelegateHandler"],
     "debugOnly": true
+  },
+  "android": {
+    "gradlePlugins": [
+      {
+        "id": "expo-dev-launcher-gradle-plugin",
+        "group": "expo.modules",
+        "sourceDir": "expo-dev-launcher-gradle-plugin"
+      }
+    ]
   }
 }

package/ios/EXDevLauncherController.m

@@ -78,6 +78,7 @@
     self.errorManager = [[EXDevLauncherErrorManager alloc] initWithController:self];
     self.installationIDHelper = [EXDevLauncherInstallationIDHelper new];
     self.shouldPreferUpdatesInterfaceSourceUrl = NO;
+    [EXDevLauncherNetworkLogger.shared enable];
   }
   return self;
 }

package/ios/EXDevLauncherUpdatesHelper.m

@@ -22,7 +22,8 @@ NS_ASSUME_NONNULL_BEGIN
     @"EXUpdatesCheckOnLaunch": @"ALWAYS",
     @"EXUpdatesHasEmbeddedUpdate": @(NO),
     @"EXUpdatesEnabled": @(YES),
-    @"EXUpdatesRequestHeaders": requestHeaders
+    @"EXUpdatesRequestHeaders": requestHeaders,
+    @"EXUpdatesExpectsSignedManifest": @(NO),
   };
 }
 

package/ios/EXDevLauncherUtils.swift

@@ -23,6 +23,47 @@ class EXDevLauncherUtils {
     }
   }
 
+  /**
+   Swizzles implementations of given class method selectors.
+   This function will backup original selector implementation for `invokeOriginalClassMethod`.
+   */
+  static func swizzleClassMethod(selector selectorA: Selector, withSelector selectorB: Selector, forClass: AnyClass) {
+    if let methodA = class_getClassMethod(forClass, selectorA),
+      let methodB = class_getClassMethod(forClass, selectorB) {
+      let impA = method_getImplementation(methodA)
+      let backupSelectorA = NSSelectorFromString("_" + NSStringFromSelector(selectorA))
+      let metaClass = objc_getMetaClass(String(describing: forClass)) as? AnyClass
+      class_addMethod(metaClass, backupSelectorA, impA, method_getTypeEncoding(methodA))
+      method_setImplementation(methodA, method_getImplementation(methodB))
+    }
+  }
+
+  /**
+   Invokes the original implementation before swizzling for the given selector
+   */
+  static func invokeOriginalClassMethod(selector: Selector, forClass: AnyClass) throws -> Any? {
+    typealias ClassMethod = @convention(c) (AnyObject, Selector) -> Any
+    let imp = try getOriginalClassMethodImp(selector: selector, forClass: forClass)
+    return unsafeBitCast(imp, to: ClassMethod.self)(self, selector)
+  }
+
+  /**
+   Invokes the original implementation before swizzling for the given selector
+   */
+  static func invokeOriginalClassMethod(selector: Selector, forClass: AnyClass, A0: Any) throws -> Any? {
+    typealias ClassMethod = @convention(c) (AnyObject, Selector, Any) -> Any
+    let imp = try getOriginalClassMethodImp(selector: selector, forClass: forClass)
+    return unsafeBitCast(imp, to: ClassMethod.self)(self, selector, A0)
+  }
+
+  private static func getOriginalClassMethodImp(selector: Selector, forClass: AnyClass) throws -> IMP {
+    let backupSelector = NSSelectorFromString("_" + NSStringFromSelector(selector))
+    guard let method = class_getClassMethod(forClass, backupSelector) else {
+      fatalError("Backup selector does not exist - forClass[\(forClass)] backupSelector[\(NSStringFromSelector(backupSelector))]")
+    }
+    return method_getImplementation(method)
+  }
+
   static func resourcesBundle() -> Bundle? {
     let frameworkBundle = Bundle(for: EXDevLauncherUtils.self)
 

package/ios/Network/EXDevLauncherNetworkLogger.swift

@@ -0,0 +1,234 @@
+import React
+
+#if DEBUG && EX_DEV_CLIENT_NETWORK_INSPECTOR
+
+/**
+ This class intercepts all default `URLSession` requests and send CDP events to the connecting metro-inspector-proxy
+ */
+@objc
+public class EXDevLauncherNetworkLogger: NSObject {
+  private var enabled: Bool = false
+  internal var inspectorPackagerConn: RCTInspectorPackagerConnection?
+
+  @objc
+  public static let shared = EXDevLauncherNetworkLogger()
+
+  override private init() {}
+
+  @objc
+  public func enable() {
+    EXDevLauncherUtils.swizzleClassMethod(
+      selector: #selector(RCTInspectorDevServerHelper.connect(withBundleURL:)),
+      withSelector: #selector(RCTInspectorDevServerHelper.EXDevLauncher_connect(withBundleURL:)),
+      forClass: RCTInspectorDevServerHelper.self
+    )
+
+    EXDevLauncherUtils.swizzleClassMethod(
+      selector: #selector(getter: URLSessionConfiguration.default),
+      withSelector: #selector(URLSessionConfiguration.EXDevLauncher_urlSessionConfiguration),
+      forClass: URLSessionConfiguration.self
+    )
+    enabled = true
+  }
+
+  /**
+   Emits CDP `Network.requestWillBeSent` and `Network.requestWillBeSentExtraInfo` events
+   */
+  func emitNetworkWillBeSent(request: URLRequest, requestId: String, redirectResponse: HTTPURLResponse?) {
+    let now = Date().timeIntervalSince1970
+    var requestParams: [String: Any] = [
+      "url": request.url?.absoluteString,
+      "method": request.httpMethod,
+      "headers": request.allHTTPHeaderFields
+    ]
+    if let httpBody = request.httpBodyData() {
+      requestParams["postData"] = String(data: httpBody, encoding: .utf8)
+    }
+    var params = [
+      "requestId": requestId,
+      "loaderId": "",
+      "documentURL": "mobile",
+      "initiator": ["type": "script"],
+      "redirectHasExtraInfo": redirectResponse != nil,
+      "request": requestParams,
+      "referrerPolicy": "no-referrer",
+      "type": "Fetch",
+      "timestamp": now,
+      "wallTime": now
+    ] as [String: Any]
+    if let redirectResponse {
+      params["redirectResponse"] = [
+        "url": redirectResponse.url?.absoluteString,
+        "status": redirectResponse.statusCode,
+        "statusText": "",
+        "headers": redirectResponse.allHeaderFields
+      ]
+    }
+    if let data = try? JSONSerialization.data(
+      withJSONObject: ["method": "Network.requestWillBeSent", "params": params],
+      options: []
+    ), let message = String(data: data, encoding: .utf8) {
+      inspectorPackagerConn?.sendWrappedEventToAllPages(message)
+    }
+    params = [
+      "requestId": requestId,
+      "associatedCookies": [],
+      "headers": requestParams["headers"],
+      "connectTiming": [
+        "requestTime": now
+      ]
+    ] as [String: Any]
+    if let data = try? JSONSerialization.data(
+      withJSONObject: ["method": "Network.requestWillBeSentExtraInfo", "params": params],
+      options: []
+    ), let message = String(data: data, encoding: .utf8) {
+      inspectorPackagerConn?.sendWrappedEventToAllPages(message)
+    }
+  }
+
+  /**
+   Emits CDP `Network.responseReceived` and `Network.loadingFinished` events
+   */
+  func emitNetworkResponse(request: URLRequest, requestId: String, response: HTTPURLResponse) {
+    let now = Date().timeIntervalSince1970
+
+    var params = [
+      "requestId": requestId,
+      "loaderId": "",
+      "hasExtraInfo": false,
+      "response": [
+        "url": request.url?.absoluteString,
+        "status": response.statusCode,
+        "statusText": "",
+        "headers": response.allHeaderFields,
+        "mimeType": response.value(forHTTPHeaderField: "Content-Type") ?? ""
+      ],
+      "referrerPolicy": "no-referrer",
+      "type": "Fetch",
+      "timestamp": now
+    ] as [String: Any]
+    if let data = try? JSONSerialization.data(
+      withJSONObject: ["method": "Network.responseReceived", "params": params],
+      options: []
+    ), let message = String(data: data, encoding: .utf8) {
+      inspectorPackagerConn?.sendWrappedEventToAllPages(message)
+    }
+
+    params = [
+      "requestId": requestId,
+      "timestamp": now,
+      "encodedDataLength": response.expectedContentLength
+    ] as [String: Any]
+    if let data = try? JSONSerialization.data(
+      withJSONObject: [
+        "method": "Network.loadingFinished",
+        "params": params
+      ],
+      options: []
+    ), let message = String(data: data, encoding: .utf8) {
+      inspectorPackagerConn?.sendWrappedEventToAllPages(message)
+    }
+  }
+
+  /**
+   Emits our custom `Expo(Network.receivedResponseBody)` event
+   */
+  func emitNetworkDidReceiveBody(requestId: String, responseBody: Data, isText: Bool) {
+    let bodyString = isText
+      ? String(data: responseBody, encoding: .utf8)
+      : responseBody.base64EncodedString()
+    let params = [
+      "requestId": requestId,
+      "body": bodyString,
+      "base64Encoded": !isText
+    ] as [String: Any]
+    if let data = try? JSONSerialization.data(
+      withJSONObject: [
+        "method": "Expo(Network.receivedResponseBody)",
+        "params": params
+      ],
+      options: []
+    ), let message = String(data: data, encoding: .utf8) {
+      inspectorPackagerConn?.sendWrappedEventToAllPages(message)
+    }
+  }
+}
+
+extension URLSessionConfiguration {
+  private typealias GetterFunc = @convention(c) (AnyObject, Selector) -> URLSessionConfiguration
+
+  /**
+   Swizzled `URLSessionConfiguration.default` for us to add the `EXDevLauncherRequestLoggerProtocol` interceptor
+   */
+  @objc
+  static func EXDevLauncher_urlSessionConfiguration() -> URLSessionConfiguration {
+    guard let config = try? EXDevLauncherUtils.invokeOriginalClassMethod(
+      selector: #selector(getter: URLSessionConfiguration.default),
+      forClass: URLSessionConfiguration.self
+    ) as? URLSessionConfiguration else {
+      fatalError("Unable to get original URLSessionConfiguration.default")
+    }
+    var protocolClasses = config.protocolClasses
+    protocolClasses?.insert(EXDevLauncherRequestLoggerProtocol.self, at: 0)
+    config.protocolClasses = protocolClasses
+    return config
+  }
+}
+
+extension RCTInspectorDevServerHelper {
+  private typealias ConnectFunc = @convention(c) (AnyObject, Selector, URL)
+    -> RCTInspectorPackagerConnection?
+
+  /**
+   Swizzled `RCTInspectorDevServerHelper.connect(withBundleURL:)` for us to get the `RCTInspectorPackagerConnection` instance
+   */
+  @objc
+  static func EXDevLauncher_connect(withBundleURL bundleURL: URL)
+    -> RCTInspectorPackagerConnection? {
+    let inspectorPackagerConn = try? EXDevLauncherUtils.invokeOriginalClassMethod(
+      selector: #selector(RCTInspectorDevServerHelper.connect(withBundleURL:)),
+      forClass: RCTInspectorDevServerHelper.self,
+      A0: bundleURL
+    ) as? RCTInspectorPackagerConnection
+
+    EXDevLauncherNetworkLogger.shared.inspectorPackagerConn = inspectorPackagerConn
+    return inspectorPackagerConn
+  }
+}
+
+extension RCTInspectorPackagerConnection {
+  /**
+   Sends message from native to inspector proxy
+   */
+  func sendWrappedEventToAllPages(_ event: String) {
+    for page in RCTInspector.pages() {
+      perform(NSSelectorFromString("sendWrappedEvent:message:"), with: String(page.id), with: event)
+    }
+  }
+}
+
+#else
+
+@objc
+public class EXDevLauncherNetworkLogger: NSObject {
+  @objc
+  public static let shared = EXDevLauncherNetworkLogger()
+
+  override private init() {}
+
+  @objc
+  public func enable() {
+    // no-op when running on release build where RCTInspector classes not exported
+  }
+
+  func emitNetworkWillBeSent(request: URLRequest, requestId: String, redirectResponse: HTTPURLResponse?) {
+  }
+
+  func emitNetworkResponse(request: URLRequest, requestId: String, response: HTTPURLResponse) {
+  }
+
+  func emitNetworkDidReceiveBody(requestId: String, responseBody: Data, isText: Bool) {
+  }
+}
+
+#endif

package/ios/Network/EXDevLauncherRequestLoggerProtocol.swift

@@ -0,0 +1,217 @@
+/**
+ A `URLSession` interceptor to log requests and send events to the `EXDevLauncherNetworkLogger`
+ */
+@objc
+class EXDevLauncherRequestLoggerProtocol: URLProtocol, URLSessionDataDelegate {
+  private static let REQUEST_ID = "EXDevLauncherRequestLoggerProtocol.requestId"
+  private static let REDIRECT_RESPONSE = "EXDevLauncherRequestLoggerProtocol.redirectResponse"
+  static let MAX_BODY_SIZE = 1_048_576
+  private static var requestIdProvider = RequestIdProvider()
+  private lazy var urlSession = URLSession(
+    configuration: URLSessionConfiguration.default,
+    delegate: self,
+    delegateQueue: nil
+  )
+  private var dataTask_: URLSessionDataTask?
+  private let responseBody = NSMutableData()
+  private var responseIsText = false
+  private var responseContentLength: Int64 = 0
+
+  // MARK: URLProtocol implementations
+
+  override class func canInit(with request: URLRequest) -> Bool {
+    guard let scheme = request.url?.scheme else {
+      return false
+    }
+    if !["http", "https"].contains(scheme) {
+      return false
+    }
+    let isNewRequest = URLProtocol.property(
+      forKey: EXDevLauncherRequestLoggerProtocol.REQUEST_ID,
+      in: request
+    ) == nil
+    return isNewRequest
+  }
+
+  override init(
+    request: URLRequest,
+    cachedResponse: CachedURLResponse?,
+    client: URLProtocolClient?
+  ) {
+    super.init(request: request, cachedResponse: cachedResponse, client: client)
+    // swiftlint:disable force_cast
+    let mutableRequest = request as! MutableURLRequest
+    // swiftlint:enable force_cast
+    let redirectResponse = URLProtocol.property(
+      forKey: EXDevLauncherRequestLoggerProtocol.REDIRECT_RESPONSE,
+      in: request
+    ) as? RedirectResponse
+    let requestId = redirectResponse?.requestId ?? EXDevLauncherRequestLoggerProtocol.requestIdProvider.create()
+    URLProtocol.setProperty(
+      requestId,
+      forKey: EXDevLauncherRequestLoggerProtocol.REQUEST_ID,
+      in: mutableRequest
+    )
+    EXDevLauncherNetworkLogger.shared.emitNetworkWillBeSent(
+      request: mutableRequest as URLRequest,
+      requestId: requestId,
+      redirectResponse: redirectResponse?.redirectResponse
+    )
+    dataTask_ = urlSession.dataTask(with: mutableRequest as URLRequest)
+  }
+
+  override class func canonicalRequest(for request: URLRequest) -> URLRequest {
+    request
+  }
+
+  override func startLoading() {
+    dataTask_?.resume()
+  }
+
+  override func stopLoading() {
+    dataTask_?.cancel()
+  }
+
+  // MARK: URLSessionDataDelegate implementations
+
+  func urlSession(_: URLSession, dataTask _: URLSessionDataTask, didReceive data: Data) {
+    client?.urlProtocol(self, didLoad: data)
+    if responseBody.length + data.count <= EXDevLauncherRequestLoggerProtocol.MAX_BODY_SIZE {
+      responseBody.append(data)
+    }
+  }
+
+  func urlSession(
+    _: URLSession,
+    dataTask: URLSessionDataTask,
+    didReceive response: URLResponse,
+    completionHandler: @escaping (URLSession.ResponseDisposition) -> Void
+  ) {
+    if let resp = response as? HTTPURLResponse,
+      let currentRequest = dataTask.currentRequest,
+      let requestId = URLProtocol.property(
+        forKey: EXDevLauncherRequestLoggerProtocol.REQUEST_ID,
+        in: currentRequest
+      ) as? String {
+      EXDevLauncherNetworkLogger.shared.emitNetworkResponse(
+        request: request,
+        requestId: requestId,
+        response: resp
+      )
+
+      let contentType = resp.value(forHTTPHeaderField: "Content-Type")
+      responseIsText = (contentType?.starts(with: "text/") ?? false) || contentType == "application/json"
+      responseContentLength = resp.expectedContentLength
+    }
+    completionHandler(.allow)
+    client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .allowed)
+  }
+
+  func urlSession(_: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+    if let error = error {
+      client?.urlProtocol(self, didFailWithError: error)
+    } else {
+      client?.urlProtocolDidFinishLoading(self)
+      if responseContentLength > 0 && responseContentLength <= EXDevLauncherRequestLoggerProtocol.MAX_BODY_SIZE,
+        let currentRequest = task.currentRequest,
+        let requestId = URLProtocol.property(
+          forKey: EXDevLauncherRequestLoggerProtocol.REQUEST_ID,
+          in: currentRequest
+        ) as? String {
+        EXDevLauncherNetworkLogger.shared.emitNetworkDidReceiveBody(
+          requestId: requestId, responseBody: responseBody as Data, isText: responseIsText)
+      }
+    }
+  }
+
+  func urlSession(
+    _: URLSession,
+    task _: URLSessionTask,
+    willPerformHTTPRedirection response: HTTPURLResponse,
+    newRequest request: URLRequest,
+    completionHandler: @escaping (URLRequest?) -> Void
+  ) {
+    let redirectRequest: URLRequest
+    if let requestId = URLProtocol.property(forKey: EXDevLauncherRequestLoggerProtocol.REQUEST_ID, in: request) as? String {
+      // swiftlint:disable force_cast
+      let mutableRequest = request as! MutableURLRequest
+      // swiftlint:enable force_cast
+      URLProtocol.removeProperty(
+        forKey: EXDevLauncherRequestLoggerProtocol.REQUEST_ID,
+        in: mutableRequest
+      )
+      URLProtocol.setProperty(
+        RedirectResponse(requestId: requestId, redirectResponse: response),
+        forKey: EXDevLauncherRequestLoggerProtocol.REDIRECT_RESPONSE,
+        in: mutableRequest
+      )
+      redirectRequest = mutableRequest as URLRequest
+    } else {
+      redirectRequest = request
+    }
+    completionHandler(redirectRequest)
+  }
+
+  /**
+   Data structure to save the response for redirection
+   */
+  private struct RedirectResponse {
+    let requestId: String
+    let redirectResponse: HTTPURLResponse
+  }
+
+  /**
+   A helper class to create a unique request ID
+   */
+  private struct RequestIdProvider {
+    private var value: UInt64 = 0
+
+    mutating func create() -> String {
+      // We could ensure the increment thread safety,
+      // because we access this function from the same thread (com.apple.CFNetwork.CustomProtocols).
+      value += 1
+      return String(value)
+    }
+  }
+}
+
+/**
+ `URLRequest.httpBodyData()` extension to read the underlying `httpBodyStream` as Data.
+ Only read at maximum `EXDevLauncherRequestLoggerProtocol.MAX_BODY_SIZE` bytes.
+ */
+extension URLRequest {
+  func httpBodyData() -> Data? {
+    if let httpBody = self.httpBody {
+      return httpBody
+    }
+
+    if let contentLength = self.allHTTPHeaderFields?["Content-Length"],
+      let contentLengthInt = Int(contentLength),
+      contentLengthInt > EXDevLauncherRequestLoggerProtocol.MAX_BODY_SIZE {
+      return nil
+    }
+    guard let stream = self.httpBodyStream else {
+      return nil
+    }
+
+    let bufferSize: Int = 8192
+    let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
+
+    stream.open()
+    defer {
+      buffer.deallocate()
+      stream.close()
+    }
+
+    var data = Data()
+    while stream.hasBytesAvailable {
+      let chunkSize = stream.read(buffer, maxLength: bufferSize)
+      if data.count + chunkSize > EXDevLauncherRequestLoggerProtocol.MAX_BODY_SIZE {
+        return nil
+      }
+      data.append(buffer, count: chunkSize)
+    }
+
+    return data
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "expo-dev-launcher",
   "title": "Expo Development Launcher",
-  "version": "2.1.5",
+  "version": "2.2.0",
   "description": "Pre-release version of the Expo development launcher package for testing.",
   "main": "build/DevLauncher.js",
   "types": "build/DevLauncher.d.ts",
@@ -29,7 +29,7 @@
   "license": "MIT",
   "homepage": "https://docs.expo.dev",
   "dependencies": {
-    "expo-dev-menu": "2.1.3",
+    "expo-dev-menu": "2.2.0",
     "resolve-from": "^5.0.0",
     "semver": "^7.3.5"
   },
@@ -49,7 +49,7 @@
     "graphql": "^16.0.1",
     "graphql-request": "^3.6.1",
     "react": "18.2.0",
-    "react-native": "0.71.3",
+    "react-native": "0.71.6",
     "react-query": "^3.34.16",
     "url": "^0.11.0"
   },
@@ -63,5 +63,5 @@
       "./setupTests.ts"
     ]
   },
-  "gitHead": "48970be700d1ab39a92c58dc2eb36e63ad185797"
+  "gitHead": "362ed24e78a57e9839afd2925d2af4aff7e28437"
 }