appium-webdriveragent 13.2.0 → 13.2.2

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [13.2.2](https://github.com/appium/WebDriverAgent/compare/v13.2.1...v13.2.2) (2026-06-06)
+
+### Miscellaneous Chores
+
+* Refactor session creation handler ([#1149](https://github.com/appium/WebDriverAgent/issues/1149)) ([923b523](https://github.com/appium/WebDriverAgent/commit/923b523b55f880b921de2c95a82786ce0699cb9d))
+
+## [13.2.1](https://github.com/appium/WebDriverAgent/compare/v13.2.0...v13.2.1) (2026-06-06)
+
+### Miscellaneous Chores
+
+* Refactor settings handling API ([#1148](https://github.com/appium/WebDriverAgent/issues/1148)) ([ff7ac36](https://github.com/appium/WebDriverAgent/commit/ff7ac368debb22659509169a0eca530bae3dc879))
+
 ## [13.2.0](https://github.com/appium/WebDriverAgent/compare/v13.1.3...v13.2.0) (2026-05-26)
 
 ### Features

package/WebDriverAgent.xcodeproj/project.pbxproj

@@ -522,6 +522,10 @@
 		71F3E7D525417FF400E0C22B /* FBSettings.h in Headers */ = {isa = PBXBuildFile; fileRef = 71F3E7D225417FF400E0C22B /* FBSettings.h */; };
 		71F3E7D625417FF400E0C22B /* FBSettings.m in Sources */ = {isa = PBXBuildFile; fileRef = 71F3E7D325417FF400E0C22B /* FBSettings.m */; };
 		71F3E7D725417FF400E0C22B /* FBSettings.m in Sources */ = {isa = PBXBuildFile; fileRef = 71F3E7D325417FF400E0C22B /* FBSettings.m */; };
+		71F3E7D825417FF400E0C22C /* FBSettingsHandler.h in Headers */ = {isa = PBXBuildFile; fileRef = 71F3E7D625417FF400E0C22C /* FBSettingsHandler.h */; };
+		71F3E7D925417FF400E0C22C /* FBSettingsHandler.h in Headers */ = {isa = PBXBuildFile; fileRef = 71F3E7D625417FF400E0C22C /* FBSettingsHandler.h */; };
+		71F3E7DA25417FF400E0C22C /* FBSettingsHandler.m in Sources */ = {isa = PBXBuildFile; fileRef = 71F3E7D725417FF400E0C22C /* FBSettingsHandler.m */; };
+		71F3E7DB25417FF400E0C22C /* FBSettingsHandler.m in Sources */ = {isa = PBXBuildFile; fileRef = 71F3E7D725417FF400E0C22C /* FBSettingsHandler.m */; };
 		71F5BE23252E576C00EE9EBA /* XCUIElement+FBSwiping.h in Headers */ = {isa = PBXBuildFile; fileRef = 71F5BE21252E576C00EE9EBA /* XCUIElement+FBSwiping.h */; };
 		71F5BE24252E576C00EE9EBA /* XCUIElement+FBSwiping.h in Headers */ = {isa = PBXBuildFile; fileRef = 71F5BE21252E576C00EE9EBA /* XCUIElement+FBSwiping.h */; };
 		71F5BE25252E576C00EE9EBA /* XCUIElement+FBSwiping.m in Sources */ = {isa = PBXBuildFile; fileRef = 71F5BE22252E576C00EE9EBA /* XCUIElement+FBSwiping.m */; };
@@ -1114,6 +1118,8 @@
 		71E75E6C254824230099FC87 /* XCUIElementQuery+FBHelpers.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = "XCUIElementQuery+FBHelpers.m"; sourceTree = "<group>"; };
 		71F3E7D225417FF400E0C22B /* FBSettings.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = FBSettings.h; sourceTree = "<group>"; };
 		71F3E7D325417FF400E0C22B /* FBSettings.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = FBSettings.m; sourceTree = "<group>"; };
+		71F3E7D625417FF400E0C22C /* FBSettingsHandler.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = FBSettingsHandler.h; sourceTree = "<group>"; };
+		71F3E7D725417FF400E0C22C /* FBSettingsHandler.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = FBSettingsHandler.m; sourceTree = "<group>"; };
 		71F5BE21252E576C00EE9EBA /* XCUIElement+FBSwiping.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "XCUIElement+FBSwiping.h"; sourceTree = "<group>"; };
 		71F5BE22252E576C00EE9EBA /* XCUIElement+FBSwiping.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = "XCUIElement+FBSwiping.m"; sourceTree = "<group>"; };
 		71F5BE33252E5B2200EE9EBA /* FBElementSwipingTests.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = FBElementSwipingTests.m; sourceTree = "<group>"; };
@@ -1982,6 +1988,8 @@
 				EE9AB7921CAEDF0C008C271F /* FBRuntimeUtils.m */,
 				71F3E7D225417FF400E0C22B /* FBSettings.h */,
 				71F3E7D325417FF400E0C22B /* FBSettings.m */,
+				71F3E7D625417FF400E0C22C /* FBSettingsHandler.h */,
+				71F3E7D725417FF400E0C22C /* FBSettingsHandler.m */,
 				715AFABF1FFA29180053896D /* FBScreen.h */,
 				715AFAC01FFA29180053896D /* FBScreen.m */,
 				71C9EAAA25E8415A00470CD8 /* FBScreenshot.h */,
@@ -2333,6 +2341,7 @@
 				13DE7A50287C46BB003243C6 /* FBXCElementSnapshot.h in Headers */,
 				13DE7A56287CA1EC003243C6 /* FBXCElementSnapshotWrapper.h in Headers */,
 				71F3E7D525417FF400E0C22B /* FBSettings.h in Headers */,
+				71F3E7D825417FF400E0C22C /* FBSettingsHandler.h in Headers */,
 				641EE63A2240C5CA00173FCB /* XCTest.h in Headers */,
 				641EE63B2240C5CA00173FCB /* FBAlertsMonitor.h in Headers */,
 				641EE63D2240C5CA00173FCB /* FBSession.h in Headers */,
@@ -2746,6 +2755,7 @@
 				719DCF152601EAFB000E765F /* FBNotificationsHelper.h in Headers */,
 				EE35AD4A1E3B77D600A02D78 /* XCTestExpectationDelegate-Protocol.h in Headers */,
 				71F3E7D425417FF400E0C22B /* FBSettings.h in Headers */,
+				71F3E7D925417FF400E0C22C /* FBSettingsHandler.h in Headers */,
 				EE35AD641E3B77D600A02D78 /* XCTUIApplicationMonitor-Protocol.h in Headers */,
 				EE35AD591E3B77D600A02D78 /* XCTKVOExpectation.h in Headers */,
 				13DE7A43287C2A8D003243C6 /* FBXCAccessibilityElement.h in Headers */,
@@ -3159,6 +3169,7 @@
 				E444DCD624917A5E0060D7EB /* DDRange.m in Sources */,
 				641EE5D72240C5CA00173FCB /* FBScreenshotCommands.m in Sources */,
 				71F3E7D725417FF400E0C22B /* FBSettings.m in Sources */,
+				71F3E7DA25417FF400E0C22C /* FBSettingsHandler.m in Sources */,
 				641EE5D92240C5CA00173FCB /* XCUIElement+FBPickerWheel.m in Sources */,
 				641EE5DA2240C5CA00173FCB /* XCUIApplicationProcessDelay.m in Sources */,
 				641EE5DB2240C5CA00173FCB /* FBXPath.m in Sources */,
@@ -3374,6 +3385,7 @@
 				EE158AB91CBD456F00A3E3F0 /* FBAlertViewCommands.m in Sources */,
 				71BB58F12B96511800CB9BFE /* FBVideoCommands.m in Sources */,
 				71F3E7D625417FF400E0C22B /* FBSettings.m in Sources */,
+				71F3E7DB25417FF400E0C22C /* FBSettingsHandler.m in Sources */,
 				13DE7A57287CA1EC003243C6 /* FBXCElementSnapshotWrapper.m in Sources */,
 				71BB58F82B96531900CB9BFE /* FBScreenRecordingContainer.m in Sources */,
 				EE158AB31CBD456F00A3E3F0 /* XCUIElement+FBScrolling.m in Sources */,

package/WebDriverAgentLib/Commands/FBSessionCommands.m

@@ -9,7 +9,6 @@
 #import "FBSessionCommands.h"
 
 #import "FBCapabilities.h"
-#import "FBClassChainQueryParser.h"
 #import "FBConfiguration.h"
 #import "FBExceptions.h"
 #import "FBLogger.h"
@@ -17,8 +16,8 @@
 #import "FBRouteRequest.h"
 #import "FBSession.h"
 #import "FBSettings.h"
+#import "FBSettingsHandler.h"
 #import "FBRuntimeUtils.h"
-#import "FBActiveAppDetectionPoint.h"
 #import "FBXCodeCompatibility.h"
 #import "XCUIApplication+FBHelpers.h"
 #import "XCUIApplication+FBQuiescence.h"
@@ -91,134 +90,35 @@
   }
 
   NSDictionary<NSString *, id> *capabilities;
-  NSError *error;
-  if (![request.arguments[@"capabilities"] isKindOfClass:NSDictionary.class]) {
-    return FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:@"'capabilities' is mandatory to create a new session"
-                                                              traceback:nil]);
-  }
-  if (nil == (capabilities = FBParseCapabilities((NSDictionary *)request.arguments[@"capabilities"], &error))) {
-    return FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:error.localizedDescription traceback:nil]);
-  }
-
-  [FBConfiguration resetSessionSettings];
-  if (capabilities[FB_SETTING_USE_COMPACT_RESPONSES]) {
-    [FBConfiguration setShouldUseCompactResponses:[capabilities[FB_SETTING_USE_COMPACT_RESPONSES] boolValue]];
-  }
-  NSString *elementResponseAttributes = capabilities[FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES];
-  if (elementResponseAttributes) {
-    [FBConfiguration setElementResponseAttributes:elementResponseAttributes];
-  }
-  if (capabilities[FB_CAP_MAX_TYPING_FREQUENCY]) {
-    [FBConfiguration setMaxTypingFrequency:[capabilities[FB_CAP_MAX_TYPING_FREQUENCY] unsignedIntegerValue]];
-  }
-  if (capabilities[FB_CAP_USE_SINGLETON_TEST_MANAGER]) {
-    [FBConfiguration setShouldUseSingletonTestManager:[capabilities[FB_CAP_USE_SINGLETON_TEST_MANAGER] boolValue]];
-  }
-  if (capabilities[FB_CAP_DISABLE_AUTOMATIC_SCREENSHOTS]) {
-    if ([capabilities[FB_CAP_DISABLE_AUTOMATIC_SCREENSHOTS] boolValue]) {
-      [FBConfiguration disableScreenshots];
-    } else {
-      [FBConfiguration enableScreenshots];
-    }
-  }
-  if (capabilities[FB_CAP_SHOULD_TERMINATE_APP]) {
-    [FBConfiguration setShouldTerminateApp:[capabilities[FB_CAP_SHOULD_TERMINATE_APP] boolValue]];
-  }
-  NSNumber *delay = capabilities[FB_CAP_EVENT_LOOP_IDLE_DELAY_SEC];
-  if ([delay doubleValue] > 0.0) {
-    [XCUIApplicationProcessDelay setEventLoopHasIdledDelay:[delay doubleValue]];
-  } else {
-    [XCUIApplicationProcessDelay disableEventLoopDelay];
+  id<FBResponsePayload> errorResponse = [self capabilitiesFromCreateSessionRequest:request
+                                                                    capabilitiesOut:&capabilities];
+  if (nil != errorResponse) {
+    return errorResponse;
   }
 
-  if (nil != capabilities[FB_SETTING_WAIT_FOR_IDLE_TIMEOUT]) {
-    FBConfiguration.waitForIdleTimeout = [capabilities[FB_SETTING_WAIT_FOR_IDLE_TIMEOUT] doubleValue];
-  }
-
-  if (nil == capabilities[FB_CAP_FORCE_SIMULATOR_SOFTWARE_KEYBOARD_PRESENCE] ||
-      [capabilities[FB_CAP_FORCE_SIMULATOR_SOFTWARE_KEYBOARD_PRESENCE] boolValue]) {
-    [FBConfiguration forceSimulatorSoftwareKeyboardPresence];
-  }
+  [self applyConfigurationFromCapabilities:capabilities];
 
   NSString *bundleID = capabilities[FB_CAP_BUNDLE_ID];
   NSString *initialUrl = capabilities[FB_CAP_INITIAL_URL];
   XCUIApplication *app = nil;
-  if (bundleID != nil) {
-    app = [[XCUIApplication alloc] initWithBundleIdentifier:bundleID];
-    BOOL forceAppLaunch = YES;
-    if (nil != capabilities[FB_CAP_FORCE_APP_LAUNCH]) {
-      forceAppLaunch = [capabilities[FB_CAP_FORCE_APP_LAUNCH] boolValue];
-    }
-    XCUIApplicationState appState = app.state;
-    BOOL isAppRunning = appState >= XCUIApplicationStateRunningBackground;
-    if (!isAppRunning || (isAppRunning && forceAppLaunch)) {
-      app.fb_shouldWaitForQuiescence = nil == capabilities[FB_CAP_SHOULD_WAIT_FOR_QUIESCENCE]
-        || [capabilities[FB_CAP_SHOULD_WAIT_FOR_QUIESCENCE] boolValue];
-      app.launchArguments = (NSArray<NSString *> *)capabilities[FB_CAP_ARGUMENTS] ?: @[];
-      app.launchEnvironment = (NSDictionary <NSString *, NSString *> *)capabilities[FB_CAP_ENVIRNOMENT] ?: @{};
-      if (nil != initialUrl) {
-        if (app.running) {
-          [app terminate];
-        }
-        id<FBResponsePayload> errorResponse = [self openDeepLink:initialUrl
-                                                 withApplication:bundleID
-                                                         timeout:capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC]];
-        if (nil != errorResponse) {
-          return errorResponse;
-        }
-      } else {
-        NSTimeInterval defaultTimeout = _XCTApplicationStateTimeout();
-        if (nil != capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC]) {
-          _XCTSetApplicationStateTimeout([capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC] doubleValue]);
-        }
-        @try {
-          [app launch];
-        } @catch (NSException *e) {
-          return FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:e.reason traceback:nil]);
-        } @finally {
-          if (nil != capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC]) {
-            _XCTSetApplicationStateTimeout(defaultTimeout);
-          }
-        }
-      }
-      if (!app.running) {
-        NSString *errorMsg = [NSString stringWithFormat:@"Cannot launch %@ application. Make sure the correct bundle identifier has been provided in capabilities and check the device log for possible crash report occurrences", bundleID];
-        return FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:errorMsg
-                                                                  traceback:nil]);
-      }
-    } else if (appState == XCUIApplicationStateRunningBackground && !forceAppLaunch) {
-      if (nil != initialUrl) {
-        id<FBResponsePayload> errorResponse = [self openDeepLink:initialUrl
-                                                 withApplication:bundleID
-                                                         timeout:nil];
-        if (nil != errorResponse) {
-          return errorResponse;
-        }
-      } else {
-        [app activate];
-      }
-    }
+  errorResponse = [self prepareApplicationForSessionWithBundleID:bundleID
+                                                      initialUrl:initialUrl
+                                                    capabilities:capabilities
+                                                     application:&app];
+  if (nil != errorResponse) {
+    return errorResponse;
   }
 
   if (nil != initialUrl && nil == bundleID) {
-    id<FBResponsePayload> errorResponse = [self openDeepLink:initialUrl
-                                             withApplication:nil
-                                                     timeout:capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC]];
+    errorResponse = [self openDeepLink:initialUrl
+                       withApplication:nil
+                               timeout:capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC]];
     if (nil != errorResponse) {
       return errorResponse;
     }
   }
 
-  if (capabilities[FB_SETTING_DEFAULT_ALERT_ACTION]) {
-    [FBSession initWithApplication:app
-                defaultAlertAction:(id)capabilities[FB_SETTING_DEFAULT_ALERT_ACTION]];
-  } else {
-    [FBSession initWithApplication:app];
-  }
-
-  if (nil != capabilities[FB_CAP_USE_NATIVE_CACHING_STRATEGY]) {
-    FBSession.activeSession.useNativeCachingStrategy = [capabilities[FB_CAP_USE_NATIVE_CACHING_STRATEGY] boolValue];
-  }
+  [self initializeSessionWithApplication:app capabilities:capabilities];
 
   return FBResponseWithObject(FBSessionCommands.sessionInformation);
 }
@@ -324,192 +224,192 @@
 
 + (id<FBResponsePayload>)handleGetSettings:(FBRouteRequest *)request
 {
-  return FBResponseWithObject(
-    @{
-      FB_SETTING_USE_COMPACT_RESPONSES: @([FBConfiguration shouldUseCompactResponses]),
-      FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES: [FBConfiguration elementResponseAttributes],
-      FB_SETTING_MJPEG_SERVER_SCREENSHOT_QUALITY: @([FBConfiguration mjpegServerScreenshotQuality]),
-      FB_SETTING_MJPEG_SERVER_FRAMERATE: @([FBConfiguration mjpegServerFramerate]),
-      FB_SETTING_MJPEG_SCALING_FACTOR: @([FBConfiguration mjpegScalingFactor]),
-      FB_SETTING_MJPEG_FIX_ORIENTATION: @([FBConfiguration mjpegShouldFixOrientation]),
-      FB_SETTING_SCREENSHOT_QUALITY: @([FBConfiguration screenshotQuality]),
-      FB_SETTING_KEYBOARD_AUTOCORRECTION: @([FBConfiguration keyboardAutocorrection]),
-      FB_SETTING_KEYBOARD_PREDICTION: @([FBConfiguration keyboardPrediction]),
-      FB_SETTING_SNAPSHOT_MAX_DEPTH: @([FBConfiguration snapshotMaxDepth]),
-      FB_SETTING_SNAPSHOT_MAX_CHILDREN: @([FBConfiguration snapshotMaxChildren]),
-      FB_SETTING_USE_FIRST_MATCH: @([FBConfiguration useFirstMatch]),
-      FB_SETTING_WAIT_FOR_IDLE_TIMEOUT: @([FBConfiguration waitForIdleTimeout]),
-      FB_SETTING_ANIMATION_COOL_OFF_TIMEOUT: @([FBConfiguration animationCoolOffTimeout]),
-      FB_SETTING_BOUND_ELEMENTS_BY_INDEX: @([FBConfiguration boundElementsByIndex]),
-      FB_SETTING_REDUCE_MOTION: @([FBConfiguration reduceMotionEnabled]),
-      FB_SETTING_DEFAULT_ACTIVE_APPLICATION: request.session.defaultActiveApplication,
-      FB_SETTING_ACTIVE_APP_DETECTION_POINT: FBActiveAppDetectionPoint.sharedInstance.stringCoordinates,
-      FB_SETTING_ACCEPT_ALERT_BUTTON_SELECTOR: FBConfiguration.acceptAlertButtonSelector,
-      FB_SETTING_DISMISS_ALERT_BUTTON_SELECTOR: FBConfiguration.dismissAlertButtonSelector,
-      FB_SETTING_AUTO_CLICK_ALERT_SELECTOR: FBConfiguration.autoClickAlertSelector,
-      FB_SETTING_DEFAULT_ALERT_ACTION: request.session.defaultAlertAction ?: @"",
-      FB_SETTING_MAX_TYPING_FREQUENCY: @([FBConfiguration maxTypingFrequency]),
-      FB_SETTING_RESPECT_SYSTEM_ALERTS: @([FBConfiguration shouldRespectSystemAlerts]),
-      FB_SETTING_USE_CLEAR_TEXT_SHORTCUT: @([FBConfiguration useClearTextShortcut]),
-      FB_SETTING_INCLUDE_HITTABLE_IN_PAGE_SOURCE: @([FBConfiguration includeHittableInPageSource]),
-      FB_SETTING_INCLUDE_NATIVE_FRAME_IN_PAGE_SOURCE: @([FBConfiguration includeNativeFrameInPageSource]),
-      FB_SETTING_INCLUDE_MIN_MAX_VALUE_IN_PAGE_SOURCE: @([FBConfiguration includeMinMaxValueInPageSource]),
-      FB_SETTING_INCLUDE_CUSTOM_ACTIONS_IN_PAGE_SOURCE: @([FBConfiguration includeCustomActionsInPageSource]),
-      FB_SETTING_ENFORCE_CUSTOM_SNAPSHOTS: @([FBConfiguration enforceCustomSnapshots]),
-      FB_SETTING_LIMIT_XPATH_CONTEXT_SCOPE: @([FBConfiguration limitXpathContextScope]),
-#if !TARGET_OS_TV
-      FB_SETTING_SCREENSHOT_ORIENTATION: [FBConfiguration humanReadableScreenshotOrientation],
-#endif
-    }
-  );
+  return FBResponseWithObject([FBSettingsHandler currentSettingsForSession:request.session]);
 }
 
-// TODO if we get lots more settings, handling them with a series of if-statements will be unwieldy
-// and this should be refactored
 + (id<FBResponsePayload>)handleSetSettings:(FBRouteRequest *)request
 {
-  NSDictionary* settings = request.arguments[@"settings"];
-
-  if (nil != [settings objectForKey:FB_SETTING_USE_COMPACT_RESPONSES]) {
-    [FBConfiguration setShouldUseCompactResponses:[[settings objectForKey:FB_SETTING_USE_COMPACT_RESPONSES] boolValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES]) {
-    [FBConfiguration setElementResponseAttributes:(NSString *)[settings objectForKey:FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_MJPEG_SERVER_SCREENSHOT_QUALITY]) {
-    [FBConfiguration setMjpegServerScreenshotQuality:[[settings objectForKey:FB_SETTING_MJPEG_SERVER_SCREENSHOT_QUALITY] unsignedIntegerValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_MJPEG_SERVER_FRAMERATE]) {
-    [FBConfiguration setMjpegServerFramerate:[[settings objectForKey:FB_SETTING_MJPEG_SERVER_FRAMERATE] unsignedIntegerValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_SCREENSHOT_QUALITY]) {
-    [FBConfiguration setScreenshotQuality:[[settings objectForKey:FB_SETTING_SCREENSHOT_QUALITY] unsignedIntegerValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_MJPEG_SCALING_FACTOR]) {
-    [FBConfiguration setMjpegScalingFactor:[[settings objectForKey:FB_SETTING_MJPEG_SCALING_FACTOR] floatValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_MJPEG_FIX_ORIENTATION]) {
-    [FBConfiguration setMjpegShouldFixOrientation:[[settings objectForKey:FB_SETTING_MJPEG_FIX_ORIENTATION] boolValue]];
+  id settingsArgument = request.arguments[@"settings"];
+  if (nil != settingsArgument && ![settingsArgument isKindOfClass:NSDictionary.class]) {
+    return FBResponseWithStatus([FBCommandStatus invalidArgumentErrorWithMessage:@"settings must be a dictionary"
+                                                                       traceback:nil]);
   }
-  if (nil != [settings objectForKey:FB_SETTING_KEYBOARD_AUTOCORRECTION]) {
-    [FBConfiguration setKeyboardAutocorrection:[[settings objectForKey:FB_SETTING_KEYBOARD_AUTOCORRECTION] boolValue]];
+  NSDictionary *settings = settingsArgument ?: @{};
+  FBCommandStatus *status = [FBSettingsHandler applySettings:settings
+                                                   toSession:request.session];
+  if (status.hasError) {
+    return FBResponseWithStatus(status);
   }
-  if (nil != [settings objectForKey:FB_SETTING_KEYBOARD_PREDICTION]) {
-    [FBConfiguration setKeyboardPrediction:[[settings objectForKey:FB_SETTING_KEYBOARD_PREDICTION] boolValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_RESPECT_SYSTEM_ALERTS]) {
-    [FBConfiguration setShouldRespectSystemAlerts:[[settings objectForKey:FB_SETTING_RESPECT_SYSTEM_ALERTS] boolValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_SNAPSHOT_MAX_DEPTH]) {
-    [FBConfiguration setSnapshotMaxDepth:[[settings objectForKey:FB_SETTING_SNAPSHOT_MAX_DEPTH] intValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_SNAPSHOT_MAX_CHILDREN]) {
-    [FBConfiguration setSnapshotMaxChildren:[[settings objectForKey:FB_SETTING_SNAPSHOT_MAX_CHILDREN] intValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_USE_FIRST_MATCH]) {
-    [FBConfiguration setUseFirstMatch:[[settings objectForKey:FB_SETTING_USE_FIRST_MATCH] boolValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_BOUND_ELEMENTS_BY_INDEX]) {
-    [FBConfiguration setBoundElementsByIndex:[[settings objectForKey:FB_SETTING_BOUND_ELEMENTS_BY_INDEX] boolValue]];
+  return [self handleGetSettings:request];
+}
+
+
+#pragma mark - Session Creation Helpers
+
++ (nullable id<FBResponsePayload>)capabilitiesFromCreateSessionRequest:(FBRouteRequest *)request
+                                                         capabilitiesOut:(NSDictionary<NSString *, id> *_Nonnull *_Nonnull)capabilitiesOut
+{
+  if (![request.arguments[@"capabilities"] isKindOfClass:NSDictionary.class]) {
+    return FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:@"'capabilities' is mandatory to create a new session"
+                                                              traceback:nil]);
   }
-  if (nil != [settings objectForKey:FB_SETTING_REDUCE_MOTION]) {
-    [FBConfiguration setReduceMotionEnabled:[[settings objectForKey:FB_SETTING_REDUCE_MOTION] boolValue]];
+  NSError *error;
+  NSDictionary<NSString *, id> *capabilities = FBParseCapabilities((NSDictionary *)request.arguments[@"capabilities"], &error);
+  if (nil == capabilities) {
+    return FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:error.localizedDescription traceback:nil]);
   }
-  if (nil != [settings objectForKey:FB_SETTING_DEFAULT_ACTIVE_APPLICATION]) {
-    request.session.defaultActiveApplication = (NSString *)[settings objectForKey:FB_SETTING_DEFAULT_ACTIVE_APPLICATION];
+  *capabilitiesOut = capabilities;
+  return nil;
+}
+
++ (void)applyConfigurationFromCapabilities:(NSDictionary<NSString *, id> *)capabilities
+{
+  [FBConfiguration resetSessionSettings];
+  if (capabilities[FB_SETTING_USE_COMPACT_RESPONSES]) {
+    [FBConfiguration setShouldUseCompactResponses:[capabilities[FB_SETTING_USE_COMPACT_RESPONSES] boolValue]];
   }
-  if (nil != [settings objectForKey:FB_SETTING_ACTIVE_APP_DETECTION_POINT]) {
-    NSError *error;
-    if (![FBActiveAppDetectionPoint.sharedInstance setCoordinatesWithString:(NSString *)[settings objectForKey:FB_SETTING_ACTIVE_APP_DETECTION_POINT]
-                                                                      error:&error]) {
-      return FBResponseWithStatus([FBCommandStatus invalidArgumentErrorWithMessage:error.localizedDescription
-                                                                         traceback:nil]);
-    }
+  NSString *elementResponseAttributes = capabilities[FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES];
+  if (elementResponseAttributes) {
+    [FBConfiguration setElementResponseAttributes:elementResponseAttributes];
   }
-  if (nil != [settings objectForKey:FB_SETTING_ACCEPT_ALERT_BUTTON_SELECTOR]) {
-    [FBConfiguration setAcceptAlertButtonSelector:(NSString *)[settings objectForKey:FB_SETTING_ACCEPT_ALERT_BUTTON_SELECTOR]];
+  if (capabilities[FB_CAP_MAX_TYPING_FREQUENCY]) {
+    [FBConfiguration setMaxTypingFrequency:[capabilities[FB_CAP_MAX_TYPING_FREQUENCY] unsignedIntegerValue]];
   }
-  if (nil != [settings objectForKey:FB_SETTING_DISMISS_ALERT_BUTTON_SELECTOR]) {
-    [FBConfiguration setDismissAlertButtonSelector:(NSString *)[settings objectForKey:FB_SETTING_DISMISS_ALERT_BUTTON_SELECTOR]];
+  if (capabilities[FB_CAP_USE_SINGLETON_TEST_MANAGER]) {
+    [FBConfiguration setShouldUseSingletonTestManager:[capabilities[FB_CAP_USE_SINGLETON_TEST_MANAGER] boolValue]];
   }
-  if (nil != [settings objectForKey:FB_SETTING_AUTO_CLICK_ALERT_SELECTOR]) {
-    FBCommandStatus *status = [self.class configureAutoClickAlertWithSelector:settings[FB_SETTING_AUTO_CLICK_ALERT_SELECTOR]
-                                                                   forSession:request.session];
-    if (status.hasError) {
-      return FBResponseWithStatus(status);
+  if (capabilities[FB_CAP_DISABLE_AUTOMATIC_SCREENSHOTS]) {
+    if ([capabilities[FB_CAP_DISABLE_AUTOMATIC_SCREENSHOTS] boolValue]) {
+      [FBConfiguration disableScreenshots];
+    } else {
+      [FBConfiguration enableScreenshots];
     }
   }
-  if (nil != [settings objectForKey:FB_SETTING_WAIT_FOR_IDLE_TIMEOUT]) {
-    [FBConfiguration setWaitForIdleTimeout:[[settings objectForKey:FB_SETTING_WAIT_FOR_IDLE_TIMEOUT] doubleValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_ANIMATION_COOL_OFF_TIMEOUT]) {
-    [FBConfiguration setAnimationCoolOffTimeout:[[settings objectForKey:FB_SETTING_ANIMATION_COOL_OFF_TIMEOUT] doubleValue]];
-  }
-  if ([[settings objectForKey:FB_SETTING_DEFAULT_ALERT_ACTION] isKindOfClass:NSString.class]) {
-    request.session.defaultAlertAction = [settings[FB_SETTING_DEFAULT_ALERT_ACTION] lowercaseString];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_MAX_TYPING_FREQUENCY]) {
-    [FBConfiguration setMaxTypingFrequency:[[settings objectForKey:FB_SETTING_MAX_TYPING_FREQUENCY] unsignedIntegerValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_USE_CLEAR_TEXT_SHORTCUT]) {
-    [FBConfiguration setUseClearTextShortcut:[[settings objectForKey:FB_SETTING_USE_CLEAR_TEXT_SHORTCUT] boolValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_INCLUDE_HITTABLE_IN_PAGE_SOURCE]) {
-    [FBConfiguration setIncludeHittableInPageSource:[[settings objectForKey:FB_SETTING_INCLUDE_HITTABLE_IN_PAGE_SOURCE] boolValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_INCLUDE_NATIVE_FRAME_IN_PAGE_SOURCE]) {
-    [FBConfiguration setIncludeNativeFrameInPageSource:[[settings objectForKey:FB_SETTING_INCLUDE_NATIVE_FRAME_IN_PAGE_SOURCE] boolValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_INCLUDE_MIN_MAX_VALUE_IN_PAGE_SOURCE]) {
-    [FBConfiguration setIncludeMinMaxValueInPageSource:[[settings objectForKey:FB_SETTING_INCLUDE_MIN_MAX_VALUE_IN_PAGE_SOURCE] boolValue]];
+  if (capabilities[FB_CAP_SHOULD_TERMINATE_APP]) {
+    [FBConfiguration setShouldTerminateApp:[capabilities[FB_CAP_SHOULD_TERMINATE_APP] boolValue]];
   }
-  if (nil != [settings objectForKey:FB_SETTING_INCLUDE_CUSTOM_ACTIONS_IN_PAGE_SOURCE]) {
-    [FBConfiguration setIncludeCustomActionsInPageSource:[[settings objectForKey:FB_SETTING_INCLUDE_CUSTOM_ACTIONS_IN_PAGE_SOURCE] boolValue]];
+  NSNumber *delay = capabilities[FB_CAP_EVENT_LOOP_IDLE_DELAY_SEC];
+  if ([delay doubleValue] > 0.0) {
+    [XCUIApplicationProcessDelay setEventLoopHasIdledDelay:[delay doubleValue]];
+  } else {
+    [XCUIApplicationProcessDelay disableEventLoopDelay];
   }
-  if (nil != [settings objectForKey:FB_SETTING_ENFORCE_CUSTOM_SNAPSHOTS]) {
-    [FBConfiguration setEnforceCustomSnapshots:[[settings objectForKey:FB_SETTING_ENFORCE_CUSTOM_SNAPSHOTS] boolValue]];
+  if (nil != capabilities[FB_SETTING_WAIT_FOR_IDLE_TIMEOUT]) {
+    FBConfiguration.waitForIdleTimeout = [capabilities[FB_SETTING_WAIT_FOR_IDLE_TIMEOUT] doubleValue];
   }
-  if (nil != [settings objectForKey:FB_SETTING_LIMIT_XPATH_CONTEXT_SCOPE]) {
-    [FBConfiguration setLimitXpathContextScope:[[settings objectForKey:FB_SETTING_LIMIT_XPATH_CONTEXT_SCOPE] boolValue]];
+  if (nil == capabilities[FB_CAP_FORCE_SIMULATOR_SOFTWARE_KEYBOARD_PRESENCE] ||
+      [capabilities[FB_CAP_FORCE_SIMULATOR_SOFTWARE_KEYBOARD_PRESENCE] boolValue]) {
+    [FBConfiguration forceSimulatorSoftwareKeyboardPresence];
   }
+}
 
-#if !TARGET_OS_TV
-  if (nil != [settings objectForKey:FB_SETTING_SCREENSHOT_ORIENTATION]) {
-    NSError *error;
-    if (![FBConfiguration setScreenshotOrientation:(NSString *)[settings objectForKey:FB_SETTING_SCREENSHOT_ORIENTATION]
-                                             error:&error]) {
-      return FBResponseWithStatus([FBCommandStatus invalidArgumentErrorWithMessage:error.localizedDescription
-                                                                         traceback:nil]);
++ (nullable id<FBResponsePayload>)prepareApplicationForSessionWithBundleID:(nullable NSString *)bundleID
+                                                                initialUrl:(nullable NSString *)initialUrl
+                                                            capabilities:(NSDictionary<NSString *, id> *)capabilities
+                                                             application:(XCUIApplication *_Nullable *_Nonnull)applicationOut
+{
+  if (nil == bundleID) {
+    *applicationOut = nil;
+    return nil;
+  }
+
+  XCUIApplication *app = [[XCUIApplication alloc] initWithBundleIdentifier:bundleID];
+  BOOL forceAppLaunch = nil == capabilities[FB_CAP_FORCE_APP_LAUNCH]
+    || [capabilities[FB_CAP_FORCE_APP_LAUNCH] boolValue];
+  XCUIApplicationState appState = app.state;
+  BOOL isAppRunning = appState >= XCUIApplicationStateRunningBackground;
+
+  if (!isAppRunning || (isAppRunning && forceAppLaunch)) {
+    id<FBResponsePayload> errorResponse = [self launchApplication:app
+                                                         bundleID:bundleID
+                                                       initialUrl:initialUrl
+                                                     capabilities:capabilities];
+    if (nil != errorResponse) {
+      return errorResponse;
+    }
+  } else if (appState == XCUIApplicationStateRunningBackground && !forceAppLaunch) {
+    id<FBResponsePayload> errorResponse = [self activateBackgroundApplication:app
+                                                                     bundleID:bundleID
+                                                                   initialUrl:initialUrl];
+    if (nil != errorResponse) {
+      return errorResponse;
     }
   }
-#endif
 
-  return [self handleGetSettings:request];
+  *applicationOut = app;
+  return nil;
 }
 
++ (nullable id<FBResponsePayload>)launchApplication:(XCUIApplication *)app
+                                           bundleID:(NSString *)bundleID
+                                         initialUrl:(nullable NSString *)initialUrl
+                                       capabilities:(NSDictionary<NSString *, id> *)capabilities
+{
+  app.fb_shouldWaitForQuiescence = nil == capabilities[FB_CAP_SHOULD_WAIT_FOR_QUIESCENCE]
+    || [capabilities[FB_CAP_SHOULD_WAIT_FOR_QUIESCENCE] boolValue];
+  app.launchArguments = (NSArray<NSString *> *)capabilities[FB_CAP_ARGUMENTS] ?: @[];
+  app.launchEnvironment = (NSDictionary<NSString *, NSString *> *)capabilities[FB_CAP_ENVIRNOMENT] ?: @{};
+
+  if (nil != initialUrl) {
+    if (app.running) {
+      [app terminate];
+    }
+    id<FBResponsePayload> errorResponse = [self openDeepLink:initialUrl
+                                               withApplication:bundleID
+                                                       timeout:capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC]];
+    if (nil != errorResponse) {
+      return errorResponse;
+    }
+  } else {
+    NSTimeInterval defaultTimeout = _XCTApplicationStateTimeout();
+    if (nil != capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC]) {
+      _XCTSetApplicationStateTimeout([capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC] doubleValue]);
+    }
+    @try {
+      [app launch];
+    } @catch (NSException *e) {
+      return FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:e.reason traceback:nil]);
+    } @finally {
+      if (nil != capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC]) {
+        _XCTSetApplicationStateTimeout(defaultTimeout);
+      }
+    }
+  }
 
-#pragma mark - Helpers
+  if (!app.running) {
+    NSString *errorMsg = [NSString stringWithFormat:@"Cannot launch %@ application. Make sure the correct bundle identifier has been provided in capabilities and check the device log for possible crash report occurrences", bundleID];
+    return FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:errorMsg traceback:nil]);
+  }
+  return nil;
+}
 
-+ (FBCommandStatus *)configureAutoClickAlertWithSelector:(NSString *)selector
-                                              forSession:(FBSession *)session
++ (nullable id<FBResponsePayload>)activateBackgroundApplication:(XCUIApplication *)app
+                                                       bundleID:(NSString *)bundleID
+                                                     initialUrl:(nullable NSString *)initialUrl
 {
-  if (0 == [selector length]) {
-    [FBConfiguration setAutoClickAlertSelector:selector];
-    [session disableAlertsMonitor];
-    return [FBCommandStatus ok];
+  if (nil != initialUrl) {
+    return [self openDeepLink:initialUrl withApplication:bundleID timeout:nil];
   }
+  [app activate];
+  return nil;
+}
 
-  NSError *error;
-  FBClassChain *parsedChain = [FBClassChainQueryParser parseQuery:selector error:&error];
-  if (nil == parsedChain) {
-    return [FBCommandStatus invalidSelectorErrorWithMessage:error.localizedDescription
-                                                  traceback:nil];
-  }
-  [FBConfiguration setAutoClickAlertSelector:selector];
-  [session enableAlertsMonitor];
-  return [FBCommandStatus ok];
++ (void)initializeSessionWithApplication:(nullable XCUIApplication *)app
+                          capabilities:(NSDictionary<NSString *, id> *)capabilities
+{
+  if (capabilities[FB_SETTING_DEFAULT_ALERT_ACTION]) {
+    [FBSession initWithApplication:app
+                defaultAlertAction:(id)capabilities[FB_SETTING_DEFAULT_ALERT_ACTION]];
+  } else {
+    [FBSession initWithApplication:app];
+  }
+  if (nil != capabilities[FB_CAP_USE_NATIVE_CACHING_STRATEGY]) {
+    FBSession.activeSession.useNativeCachingStrategy = [capabilities[FB_CAP_USE_NATIVE_CACHING_STRATEGY] boolValue];
+  }
 }
 
+#pragma mark - Helpers
+
 + (NSString *)buildTimestamp
 {
   return [NSString stringWithFormat:@"%@ %@",

package/WebDriverAgentLib/Info.plist

@@ -15,11 +15,11 @@
     <key>CFBundlePackageType</key>
     <string>FMWK</string>
     <key>CFBundleShortVersionString</key>
-    <string>13.2.0</string>
+    <string>13.2.2</string>
     <key>CFBundleSignature</key>
     <string>????</string>
     <key>CFBundleVersion</key>
-    <string>13.2.0</string>
+    <string>13.2.2</string>
     <key>NSPrincipalClass</key>
     <string/>
   </dict>

package/WebDriverAgentLib/Utilities/FBSettingsHandler.h

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+@class FBCommandStatus;
+@class FBSession;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface FBSettingsHandler : NSObject
+
+/**
+ * Applies the given settings dictionary to FBConfiguration and the active session.
+ * JSON null values are normalized to nil. Nil is applied only for settings that
+ * support clearing (e.g. alert action and selectors); other keys are skipped so
+ * null does not get coerced to NO/0. Unknown keys are skipped.
+ *
+ * @return nil on success, or an FBCommandStatus describing the validation error.
+ */
++ (nullable FBCommandStatus *)applySettings:(NSDictionary *)settings toSession:(FBSession *)session;
+
+/**
+ * Returns the current values for all known settings.
+ */
++ (NSDictionary *)currentSettingsForSession:(FBSession *)session;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/WebDriverAgentLib/Utilities/FBSettingsHandler.m

@@ -0,0 +1,356 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "FBSettingsHandler.h"
+
+#import "FBActiveAppDetectionPoint.h"
+#import "FBClassChainQueryParser.h"
+#import "FBCommandStatus.h"
+#import "FBConfiguration.h"
+#import "FBSession.h"
+#import "FBSettings.h"
+
+typedef FBCommandStatus * _Nullable (^FBSettingApplyBlock)(FBSession *session, id value);
+typedef id _Nonnull (^FBSettingGetBlock)(FBSession *session);
+
+static id FBNormalizedSettingValue(id value)
+{
+  return value == NSNull.null ? nil : value;
+}
+
+static NSSet<NSString *> *FBNilClearableSettingKeys(void)
+{
+  static NSSet<NSString *> *keys;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    keys = [NSSet setWithObjects:
+      FB_SETTING_DEFAULT_ALERT_ACTION,
+      FB_SETTING_ACCEPT_ALERT_BUTTON_SELECTOR,
+      FB_SETTING_DISMISS_ALERT_BUTTON_SELECTOR,
+      FB_SETTING_AUTO_CLICK_ALERT_SELECTOR,
+      nil];
+  });
+  return keys;
+}
+
+@implementation FBSettingsHandler
+
++ (NSDictionary<NSString *, FBSettingApplyBlock> *)settersMap
+{
+  static NSDictionary<NSString *, FBSettingApplyBlock> *settersMap;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    NSMutableDictionary<NSString *, FBSettingApplyBlock> *map = [NSMutableDictionary dictionary];
+    map[FB_SETTING_USE_COMPACT_RESPONSES] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setShouldUseCompactResponses:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setElementResponseAttributes:(NSString *)value];
+      return nil;
+    };
+    map[FB_SETTING_MJPEG_SERVER_SCREENSHOT_QUALITY] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setMjpegServerScreenshotQuality:[value unsignedIntegerValue]];
+      return nil;
+    };
+    map[FB_SETTING_MJPEG_SERVER_FRAMERATE] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setMjpegServerFramerate:[value unsignedIntegerValue]];
+      return nil;
+    };
+    map[FB_SETTING_SCREENSHOT_QUALITY] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setScreenshotQuality:[value unsignedIntegerValue]];
+      return nil;
+    };
+    map[FB_SETTING_MJPEG_SCALING_FACTOR] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setMjpegScalingFactor:[value floatValue]];
+      return nil;
+    };
+    map[FB_SETTING_MJPEG_FIX_ORIENTATION] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setMjpegShouldFixOrientation:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_KEYBOARD_AUTOCORRECTION] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setKeyboardAutocorrection:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_KEYBOARD_PREDICTION] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setKeyboardPrediction:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_RESPECT_SYSTEM_ALERTS] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setShouldRespectSystemAlerts:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_SNAPSHOT_MAX_DEPTH] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setSnapshotMaxDepth:[value intValue]];
+      return nil;
+    };
+    map[FB_SETTING_SNAPSHOT_MAX_CHILDREN] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setSnapshotMaxChildren:[value intValue]];
+      return nil;
+    };
+    map[FB_SETTING_USE_FIRST_MATCH] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setUseFirstMatch:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_BOUND_ELEMENTS_BY_INDEX] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setBoundElementsByIndex:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_REDUCE_MOTION] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setReduceMotionEnabled:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_DEFAULT_ACTIVE_APPLICATION] = ^FBCommandStatus *(FBSession *session, id value) {
+      session.defaultActiveApplication = (NSString *)value;
+      return nil;
+    };
+    map[FB_SETTING_ACTIVE_APP_DETECTION_POINT] = ^FBCommandStatus *(FBSession *session, id value) {
+      NSError *error;
+      if (![FBActiveAppDetectionPoint.sharedInstance setCoordinatesWithString:(NSString *)value
+                                                                        error:&error]) {
+        return [FBCommandStatus invalidArgumentErrorWithMessage:error.localizedDescription
+                                                      traceback:nil];
+      }
+      return nil;
+    };
+    map[FB_SETTING_ACCEPT_ALERT_BUTTON_SELECTOR] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setAcceptAlertButtonSelector:(NSString *)value];
+      return nil;
+    };
+    map[FB_SETTING_DISMISS_ALERT_BUTTON_SELECTOR] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setDismissAlertButtonSelector:(NSString *)value];
+      return nil;
+    };
+    map[FB_SETTING_AUTO_CLICK_ALERT_SELECTOR] = ^FBCommandStatus *(FBSession *session, id value) {
+      return [self configureAutoClickAlertWithSelector:(NSString *)value forSession:session];
+    };
+    map[FB_SETTING_WAIT_FOR_IDLE_TIMEOUT] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setWaitForIdleTimeout:[value doubleValue]];
+      return nil;
+    };
+    map[FB_SETTING_ANIMATION_COOL_OFF_TIMEOUT] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setAnimationCoolOffTimeout:[value doubleValue]];
+      return nil;
+    };
+    map[FB_SETTING_DEFAULT_ALERT_ACTION] = ^FBCommandStatus *(FBSession *session, id value) {
+      if (nil == value) {
+        session.defaultAlertAction = nil;
+      } else if ([value isKindOfClass:NSString.class]) {
+        session.defaultAlertAction = [(NSString *)value lowercaseString];
+      }
+      return nil;
+    };
+    map[FB_SETTING_MAX_TYPING_FREQUENCY] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setMaxTypingFrequency:[value unsignedIntegerValue]];
+      return nil;
+    };
+    map[FB_SETTING_USE_CLEAR_TEXT_SHORTCUT] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setUseClearTextShortcut:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_INCLUDE_HITTABLE_IN_PAGE_SOURCE] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setIncludeHittableInPageSource:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_INCLUDE_NATIVE_FRAME_IN_PAGE_SOURCE] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setIncludeNativeFrameInPageSource:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_INCLUDE_MIN_MAX_VALUE_IN_PAGE_SOURCE] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setIncludeMinMaxValueInPageSource:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_INCLUDE_CUSTOM_ACTIONS_IN_PAGE_SOURCE] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setIncludeCustomActionsInPageSource:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_ENFORCE_CUSTOM_SNAPSHOTS] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setEnforceCustomSnapshots:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_LIMIT_XPATH_CONTEXT_SCOPE] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setLimitXpathContextScope:[value boolValue]];
+      return nil;
+    };
+#if !TARGET_OS_TV
+    map[FB_SETTING_SCREENSHOT_ORIENTATION] = ^FBCommandStatus *(FBSession *session, id value) {
+      NSError *error;
+      if (![FBConfiguration setScreenshotOrientation:(NSString *)value error:&error]) {
+        return [FBCommandStatus invalidArgumentErrorWithMessage:error.localizedDescription
+                                                      traceback:nil];
+      }
+      return nil;
+    };
+#endif
+    settersMap = map.copy;
+  });
+  return settersMap;
+}
+
++ (NSDictionary<NSString *, FBSettingGetBlock> *)gettersMap
+{
+  static NSDictionary<NSString *, FBSettingGetBlock> *gettersMap;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    NSMutableDictionary<NSString *, FBSettingGetBlock> *map = [NSMutableDictionary dictionary];
+    map[FB_SETTING_USE_COMPACT_RESPONSES] = ^id(FBSession *session) {
+      return @([FBConfiguration shouldUseCompactResponses]);
+    };
+    map[FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES] = ^id(FBSession *session) {
+      return [FBConfiguration elementResponseAttributes];
+    };
+    map[FB_SETTING_MJPEG_SERVER_SCREENSHOT_QUALITY] = ^id(FBSession *session) {
+      return @([FBConfiguration mjpegServerScreenshotQuality]);
+    };
+    map[FB_SETTING_MJPEG_SERVER_FRAMERATE] = ^id(FBSession *session) {
+      return @([FBConfiguration mjpegServerFramerate]);
+    };
+    map[FB_SETTING_MJPEG_SCALING_FACTOR] = ^id(FBSession *session) {
+      return @([FBConfiguration mjpegScalingFactor]);
+    };
+    map[FB_SETTING_MJPEG_FIX_ORIENTATION] = ^id(FBSession *session) {
+      return @([FBConfiguration mjpegShouldFixOrientation]);
+    };
+    map[FB_SETTING_SCREENSHOT_QUALITY] = ^id(FBSession *session) {
+      return @([FBConfiguration screenshotQuality]);
+    };
+    map[FB_SETTING_KEYBOARD_AUTOCORRECTION] = ^id(FBSession *session) {
+      return @([FBConfiguration keyboardAutocorrection]);
+    };
+    map[FB_SETTING_KEYBOARD_PREDICTION] = ^id(FBSession *session) {
+      return @([FBConfiguration keyboardPrediction]);
+    };
+    map[FB_SETTING_SNAPSHOT_MAX_DEPTH] = ^id(FBSession *session) {
+      return @([FBConfiguration snapshotMaxDepth]);
+    };
+    map[FB_SETTING_SNAPSHOT_MAX_CHILDREN] = ^id(FBSession *session) {
+      return @([FBConfiguration snapshotMaxChildren]);
+    };
+    map[FB_SETTING_USE_FIRST_MATCH] = ^id(FBSession *session) {
+      return @([FBConfiguration useFirstMatch]);
+    };
+    map[FB_SETTING_WAIT_FOR_IDLE_TIMEOUT] = ^id(FBSession *session) {
+      return @([FBConfiguration waitForIdleTimeout]);
+    };
+    map[FB_SETTING_ANIMATION_COOL_OFF_TIMEOUT] = ^id(FBSession *session) {
+      return @([FBConfiguration animationCoolOffTimeout]);
+    };
+    map[FB_SETTING_BOUND_ELEMENTS_BY_INDEX] = ^id(FBSession *session) {
+      return @([FBConfiguration boundElementsByIndex]);
+    };
+    map[FB_SETTING_REDUCE_MOTION] = ^id(FBSession *session) {
+      return @([FBConfiguration reduceMotionEnabled]);
+    };
+    map[FB_SETTING_DEFAULT_ACTIVE_APPLICATION] = ^id(FBSession *session) {
+      return session.defaultActiveApplication;
+    };
+    map[FB_SETTING_ACTIVE_APP_DETECTION_POINT] = ^id(FBSession *session) {
+      return FBActiveAppDetectionPoint.sharedInstance.stringCoordinates;
+    };
+    map[FB_SETTING_ACCEPT_ALERT_BUTTON_SELECTOR] = ^id(FBSession *session) {
+      return FBConfiguration.acceptAlertButtonSelector;
+    };
+    map[FB_SETTING_DISMISS_ALERT_BUTTON_SELECTOR] = ^id(FBSession *session) {
+      return FBConfiguration.dismissAlertButtonSelector;
+    };
+    map[FB_SETTING_AUTO_CLICK_ALERT_SELECTOR] = ^id(FBSession *session) {
+      return FBConfiguration.autoClickAlertSelector;
+    };
+    map[FB_SETTING_DEFAULT_ALERT_ACTION] = ^id(FBSession *session) {
+      return session.defaultAlertAction ?: @"";
+    };
+    map[FB_SETTING_MAX_TYPING_FREQUENCY] = ^id(FBSession *session) {
+      return @([FBConfiguration maxTypingFrequency]);
+    };
+    map[FB_SETTING_RESPECT_SYSTEM_ALERTS] = ^id(FBSession *session) {
+      return @([FBConfiguration shouldRespectSystemAlerts]);
+    };
+    map[FB_SETTING_USE_CLEAR_TEXT_SHORTCUT] = ^id(FBSession *session) {
+      return @([FBConfiguration useClearTextShortcut]);
+    };
+    map[FB_SETTING_INCLUDE_HITTABLE_IN_PAGE_SOURCE] = ^id(FBSession *session) {
+      return @([FBConfiguration includeHittableInPageSource]);
+    };
+    map[FB_SETTING_INCLUDE_NATIVE_FRAME_IN_PAGE_SOURCE] = ^id(FBSession *session) {
+      return @([FBConfiguration includeNativeFrameInPageSource]);
+    };
+    map[FB_SETTING_INCLUDE_MIN_MAX_VALUE_IN_PAGE_SOURCE] = ^id(FBSession *session) {
+      return @([FBConfiguration includeMinMaxValueInPageSource]);
+    };
+    map[FB_SETTING_INCLUDE_CUSTOM_ACTIONS_IN_PAGE_SOURCE] = ^id(FBSession *session) {
+      return @([FBConfiguration includeCustomActionsInPageSource]);
+    };
+    map[FB_SETTING_ENFORCE_CUSTOM_SNAPSHOTS] = ^id(FBSession *session) {
+      return @([FBConfiguration enforceCustomSnapshots]);
+    };
+    map[FB_SETTING_LIMIT_XPATH_CONTEXT_SCOPE] = ^id(FBSession *session) {
+      return @([FBConfiguration limitXpathContextScope]);
+    };
+#if !TARGET_OS_TV
+    map[FB_SETTING_SCREENSHOT_ORIENTATION] = ^id(FBSession *session) {
+      return [FBConfiguration humanReadableScreenshotOrientation];
+    };
+#endif
+    gettersMap = map.copy;
+  });
+  return gettersMap;
+}
+
++ (NSDictionary *)currentSettingsForSession:(FBSession *)session
+{
+  NSDictionary<NSString *, FBSettingGetBlock> *gettersMap = [self gettersMap];
+  NSMutableDictionary *settings = [NSMutableDictionary dictionaryWithCapacity:gettersMap.count];
+  for (NSString *key in gettersMap) {
+    settings[key] = gettersMap[key](session);
+  }
+  return settings.copy;
+}
+
++ (nullable FBCommandStatus *)applySettings:(NSDictionary *)settings toSession:(FBSession *)session
+{
+  NSDictionary<NSString *, FBSettingApplyBlock> *settersMap = [self settersMap];
+  NSSet<NSString *> *nilClearableKeys = FBNilClearableSettingKeys();
+  for (NSString *key in settings) {
+    FBSettingApplyBlock handler = settersMap[key];
+    if (nil == handler) {
+      continue;
+    }
+    id value = FBNormalizedSettingValue(settings[key]);
+    if (nil == value && ![nilClearableKeys containsObject:key]) {
+      continue;
+    }
+    FBCommandStatus *status = handler(session, value);
+    if (status.hasError) {
+      return status;
+    }
+  }
+  return nil;
+}
+
++ (FBCommandStatus *)configureAutoClickAlertWithSelector:(NSString *)selector
+                                              forSession:(FBSession *)session
+{
+  if (0 == [selector length]) {
+    [FBConfiguration setAutoClickAlertSelector:selector];
+    [session disableAlertsMonitor];
+    return [FBCommandStatus ok];
+  }
+
+  NSError *error;
+  FBClassChain *parsedChain = [FBClassChainQueryParser parseQuery:selector error:&error];
+  if (nil == parsedChain) {
+    return [FBCommandStatus invalidSelectorErrorWithMessage:error.localizedDescription
+                                                  traceback:nil];
+  }
+  [FBConfiguration setAutoClickAlertSelector:selector];
+  [session enableAlertsMonitor];
+  return [FBCommandStatus ok];
+}
+
+@end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appium-webdriveragent",
-  "version": "13.2.0",
+  "version": "13.2.2",
   "description": "Package bundling WebDriverAgent",
   "main": "./build/lib/index.js",
   "types": "./build/lib/index.d.ts",