simtap 0.0.0-stage → 0.6.0

package/vendor/axe/Frameworks/FBDeviceControl.framework/Versions/A/Headers/FBAMDServiceConnection.h

@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import <FBControlCore/FBControlCore.h>
+#import <FBDeviceControl/FBAMDefines.h>
+
+@class FBAFCConnection;
+@protocol FBControlCoreLogger;
+
+/**
+ Wraps the AMDServiceConnection.
+ An AMDServiceConnection represents a connection to a "lockdown" service over USB.
+ */
+@interface FBAMDServiceConnection : NSObject
+
+#pragma mark Initializers
+
+/**
+ The Designated Initializer.
+ Data transfer uses raw sockets.
+
+ @param name the name of the service connection.
+ @param connection the underlying AMDevice Service Connection to wrap.
+ @param device the device to use.
+ @param calls the calls to use.
+ @param logger the logger to use.
+ @return a FBAMDServiceConnection instance.
+ */
++ (nonnull instancetype)connectionWithName:(nonnull NSString *)name connection:(AMDServiceConnectionRef _Nonnull)connection device:(AMDeviceRef _Nonnull)device calls:(AMDCalls)calls logger:(nullable id<FBControlCoreLogger>)logger;
+
+#pragma mark plist Messaging
+
+// There's a common protocol that is commonly used with AMDServiceConnections (otherwise known as lockdown services).
+// As this is used by a number of different services, there's library code for this protocol in MobileDevice.framework
+// This format is built on top of sending and receiving from the AMDServiceConnection socket.
+// It's implemented in the AMDServiceConnectionSendMessage/AMDServiceConnectionReceiveMessage calls, but can also be implemented manually.
+// One reason for using these calls instead of sending raw bytes is that these library functions send encrypted traffic if there's an SSL context on the AMDServiceConnection.
+// Over the course of iOS releases, the requirement to send data using SSL has become more strictly enforced.
+//
+// The send-side of the protocol is as follows:
+// 1) Any packet has a device-endian 32-bit unsigned integer that encodes the length of a packet. This is used for both the sending and receiving side.
+// 2) The data after this is a binary-plist of the payload itself. This means that any plist-serializable data can be transmitted.
+// 3) There is no trailer for a packet, the header defines when the end of the packet is.
+// 4) The header (#1) and the binary plist (#2) are then sent over the socket. If there's an SSL context then any data that is transmitted is encrypted. When encryption is enabled, all data on the channel is encrypted, including the header
+//
+// The receive side is just the same, but in reverse:
+// 1) The header is read, it's of a fixed size so the socket receive call can be provided with a fixed value
+// 2) The header gives the size of the plist-packet read length. Once the read side has read up to the size of the payload, it is ready to be deserialized.
+// 3) As with the write side, if there's an SSL context the data will be decrypted through this context.
+
+/**
+ Synchronously send a plist-based packet used by lockdown.
+
+ @param message the message to send.
+ @param error an error out for any error that occurs.
+ @return YES if the message was sent, NO otherwise.
+ */
+- (BOOL)sendMessage:(nonnull id)message error:(NSError * _Nullable * _Nullable)error;
+
+/**
+ Synchronously receive a plist-based packet used by lockdown.
+
+ @param error an error out for any error that occurs.
+ @return the read plist on success, nil on error.
+ */
+- (nullable id)receiveMessageWithError:(NSError * _Nullable * _Nullable)error;
+
+/**
+ Send then receive a plist.
+
+ @param message the message to send.
+ @param error an error out for any error that occurs.
+ @return the message received, if successful.
+ */
+- (nullable id)sendAndReceiveMessage:(nonnull id)message error:(NSError * _Nullable * _Nullable)error;
+
+#pragma mark Raw Bytes Read/Write
+/**
+ Synchronously send bytes on the connection.
+
+ @param data the data to send
+ @param error an error out for any error that occurs.
+ @return YES if the bytes were sent, NO otherwise.
+ */
+- (BOOL)send:(nonnull NSData *)data error:(NSError * _Nullable * _Nullable)error;
+
+/**
+ Synchronously send bytes on the connection, prefixed with a length packet.
+
+ @param data the data to send>
+ @param error an error out for any error that occurs.
+ @return YES if the bytes were sent, NO otherwise.
+ */
+- (BOOL)sendWithLengthHeader:(nonnull NSData *)data error:(NSError * _Nullable * _Nullable)error;
+
+/**
+ Sends a uint32_t over the connection.
+
+ @param value the value to send.
+ @param error an error out for any error that occurs.
+ @return YES if successful, NO otherwise.
+ */
+- (BOOL)sendUnsignedInt32:(uint32_t)value error:(NSError * _Nullable * _Nullable)error;
+
+/**
+ Synchronously receive bytes from the connection.
+ This call will block until 'size' is met.
+ If a read fails before the 'size' is met, this call will fail.
+
+ @param size the number of bytes to read.
+ @param error an error out for any error that occurs.
+ @return the data.
+ */
+- (nullable NSData *)receive:(size_t)size error:(NSError * _Nullable * _Nullable)error;
+
+/**
+ Synchronously receive up to 'size' bytes in the connection
+ This call will return an empty NSData when end of file is reached.
+
+ @param size the number of bytes to read up to.
+ @param error an error out for any error that occurs.
+ @return the data.
+ */
+- (nullable NSData *)receiveUpTo:(size_t)size error:(NSError * _Nullable * _Nullable)error;
+
+/**
+ Synchronously receive bytes from the connection, writing to a file handle.
+
+ @param size the number of bytes to read.
+ @param fileHandle the file handle to write to.
+ @param error an error out for any error that occurs.
+ @return the data.
+ */
+- (BOOL)receive:(size_t)size toFile:(nonnull NSFileHandle *)fileHandle error:(NSError * _Nullable * _Nullable)error;
+
+/**
+ Synchronously receive bytes into a buffer.
+
+ @param destination the destination to write into.
+ @param size the number of bytes to read.
+ @param error an error out for any error that occurs.
+ @return YES if all bytes read, NO otherwise.
+ */
+- (BOOL)receive:(void * _Nonnull)destination ofSize:(size_t)size error:(NSError * _Nullable * _Nullable)error;
+
+/**
+ Receives a uint32_t a from the connection.
+
+ @param valueOut the value to pull.
+ @param error an error out for any error that occurs.
+ @return YES if successful, NO otherwise.
+ */
+- (BOOL)receiveUnsignedInt32:(uint32_t * _Nonnull)valueOut error:(NSError * _Nullable * _Nullable)error;
+
+/**
+ Receives a uint64_t a from the connection.
+
+ @param valueOut the value to pull.
+ @param error an error out for any error that occurs.
+ @return YES if successful, NO otherwise.
+ */
+- (BOOL)receiveUnsignedInt64:(uint64_t * _Nonnull)valueOut error:(NSError * _Nullable * _Nullable)error;
+
+#pragma mark Streams
+
+/**
+ Reads the stream on the given queue, until exhausted.
+
+ @param consumer the consumer to use.
+ @param queue the queue to consume on.
+ @return the FBFileReader instance, this can be used to start reading the receiver's connection.
+*/
+- (nonnull id<FBFileReaderProtocol>)readFromConnectionWritingToConsumer:(nonnull id<FBDataConsumer>)consumer onQueue:(nonnull dispatch_queue_t)queue;
+
+/**
+ Constructs a data consumer that writes to the underlying connection.
+
+ @param queue the queue to perform writes on.
+ @return a consumer that writes to the receiver's connection.
+*/
+- (nonnull id<FBDataConsumer, FBDataConsumerLifecycle>)writeWithConsumerWritingOnQueue:(nonnull dispatch_queue_t)queue;
+
+#pragma mark Lifecycle
+
+/**
+ Invalidates the Service connection.
+ After this is called, this object is no longer valid.
+
+ @param error an error out for any error that occurs.
+ @return YES if successful, NO otherwise.
+ */
+- (BOOL)invalidateWithError:(NSError * _Nullable * _Nullable)error;
+
+#pragma mark AFC
+
+/**
+ Constructs an AFC Connection from the underlying connection
+
+ @param calls  calls, the calls to use.
+ @param callback the callback to use for progress.
+ @param logger the logger to use for logging.
+ @return a new FBAFCConnection wrapper instance.
+ */
+- (nonnull FBAFCConnection *)asAFCConnectionWithCalls:(AFCCalls)calls callback:(AFCNotificationCallback _Nonnull)callback logger:(nonnull id<FBControlCoreLogger>)logger;
+
+#pragma mark Properties
+
+/**
+ The name of the service.
+ */
+@property (nonnull, nonatomic, readonly, copy) NSString *name;
+
+/**
+ The Wrapped Connection.
+ */
+@property (nullable, nonatomic, readonly, assign) AMDServiceConnectionRef connection;
+
+/**
+ The Device to use.
+ */
+@property (nonatomic, readonly, assign) AMDeviceRef _Nonnull device;
+
+/**
+ The Calls to use.
+ */
+@property (nonatomic, readonly, assign) AMDCalls calls;
+
+/**
+ The Logger to use.
+ */
+@property (nullable, nonatomic, readonly, strong) id<FBControlCoreLogger> logger;
+
+@end

package/vendor/axe/Frameworks/FBDeviceControl.framework/Versions/A/Headers/FBAMDefines.h

@@ -0,0 +1,256 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#pragma mark - AMDevice API
+
+/**
+ An Alias AMDeviceRef Type.
+ */
+typedef CFTypeRef AMDeviceRef;
+
+/**
+ The Connection Reference as is typically passed around between functions.
+ */
+typedef CFTypeRef AFCConnectionRef;
+
+/**
+ The Connection Reference as is typically passed around between functions.
+ */
+typedef CFTypeRef AMDServiceConnectionRef;
+
+/**
+ Used inside AFC Operations.
+ */
+typedef CFTypeRef AFCOperationRef;
+
+/**
+ An Alias for the AMRestorableDeviceRef Type.
+ */
+typedef CFTypeRef AMRestorableDeviceRef;
+
+/**
+ An Alias for the "Recovery Mode Device"
+ */
+typedef CFTypeRef AMRecoveryModeDeviceRef;
+
+/**
+ An Alias for a "Secure IO Context"
+ */
+typedef void *AMSecureIOContext;
+
+/**
+ An Alias for the MISProfileRef Type.
+ */
+typedef CFTypeRef MISProfileRef;
+
+/**
+ An opaque handle to a notification subscription.
+ */
+typedef void *AMDNotificationSubscription;
+
+/**
+ An enum for read modes.
+ */
+typedef enum : uint64_t {
+  FBAFCReadOnlyMode = 1,
+  FBAFCreateReadAndWrite = 3
+} FBAFCReadMode;
+
+/**
+ AMDevice Notification Types.
+ */
+typedef NS_ENUM(int, AMDeviceNotificationType) {
+  AMDeviceNotificationTypeConnected = 1,
+  AMDeviceNotificationTypeDisconnected = 2,
+  AMDeviceNotificationTypeUnsubscribed = 3,
+  AMDeviceNotificationTypePaired = 4,
+};
+
+typedef NS_ENUM(int, AMRestorableDeviceNotificationType) {
+  AMRestorableDeviceNotificationTypeConnected = 0,
+  AMRestorableDeviceNotificationTypeDisconnected = 1,
+};
+
+/**
+ Aliases for AMRestorableDeviceState
+ */
+typedef NS_ENUM(int, AMRestorableDeviceState) {
+  AMRestorableDeviceStateDFU = 0,
+  AMRestorableDeviceStateRecovery = 1,
+  AMRestorableDeviceStateRestoreOS = 2,
+  AMRestorableDeviceStateBootedOS = 4,
+  AMRestorableDeviceStateUnknown = 5,
+};
+
+/**
+ A Notification structure.
+ */
+typedef struct {
+  AMDeviceRef _Nonnull amDevice;
+  AMDeviceNotificationType status;
+} AMDeviceNotification;
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wnullability-completeness"
+
+/**
+ Defines the "Progress Callback" function signature.
+ */
+typedef void (*AMDeviceProgressCallback)(NSDictionary<NSString *, id> *progress, void *_Nullable context);
+
+/**
+ Defines the "Notification Callback" AMDeviceRef instances.
+ */
+typedef void (*AMDeviceNotificationCallback)(AMDeviceNotification *notification, void *_Nullable context);
+
+/**
+ Defines the "Notification Callback" for AMRestorableDeviceRef instances.
+ */
+typedef void (*AMRestorableDeviceNotificationCallback)(AMRestorableDeviceRef eventData, AMRestorableDeviceNotificationType status, void *context);
+
+/**
+ Defines the "Notification Callback" for AFCConnectionCreate call.
+ */
+typedef void (*AFCNotificationCallback)(void *connectionRefPtr, void *arg1, void *afcOperationPtr);
+
+/**
+ Defines the callback for "AMSEraseDevice".
+ */
+typedef int (*AMSEraseDeviceCallback)(NSString *identifier, int progress, void *_Nullable context);
+
+/**
+ A Structure that references to the AMDevice APIs we use.
+ */
+typedef struct {
+  // Managing Connections & Sessions.
+  int (*Connect)(AMDeviceRef device);
+  int (*Disconnect)(AMDeviceRef device);
+  int (*IsPaired)(AMDeviceRef device);
+  int (*Pair)(AMDeviceRef device);
+  int (*StartSession)(AMDeviceRef device);
+  int (*StopSession)(AMDeviceRef device);
+  int (*ValidatePairing)(AMDeviceRef device);
+
+  // Memory Management
+  void (*Retain)(AMDeviceRef device);
+  void (*Release)(AMDeviceRef device);
+
+  // Getting Properties of a Device.
+  _Nullable CFStringRef(*_Nonnull CopyDeviceIdentifier)(AMDeviceRef device);
+  _Nullable CFStringRef(*_Nonnull CopyValue)(AMDeviceRef device, _Nullable CFStringRef domain, CFStringRef name);
+
+  // Obtaining Devices.
+  _Nullable CFArrayRef (*CreateDeviceList)(void);
+  int (*NotificationSubscribe)(AMDeviceNotificationCallback callback, int arg0, int arg1, void *context, AMDNotificationSubscription *subscriptionOut);
+  int (*NotificationUnsubscribe)(AMDNotificationSubscription subscription);
+
+  // Using Connections.
+  int (*ServiceConnectionGetSocket)(CFTypeRef connection);
+  int (*ServiceConnectionInvalidate)(CFTypeRef connection);
+  int32_t (*ServiceConnectionReceive)(CFTypeRef connection, void *buffer, size_t bytes);
+  int (*ServiceConnectionReceiveMessage)(CFTypeRef connection, CFPropertyListRef *messageOut, CFPropertyListFormat *formatOut, void *unknown0, void *unknown1, void *unknown2);
+  int32_t (*ServiceConnectionSend)(CFTypeRef connection, const void *buffer, size_t bytes);
+  int (*ServiceConnectionSendMessage)(CFTypeRef connection, CFPropertyListRef propertyList, CFPropertyListFormat format, void *unknown0, CFDictionaryKeyCallBacks *keyCallbacks, CFDictionaryValueCallBacks *valueCallbacks);
+  AMSecureIOContext (*ServiceConnectionGetSecureIOContext)(CFTypeRef connection);
+
+  // Managing device recovery.
+  int (*EnterRecovery)(AMDeviceRef device);
+  AMRecoveryModeDeviceRef (*RestorableDeviceGetRecoveryModeDevice)(AMRestorableDeviceRef device);
+  int (*RecoveryModeDeviceSetAutoBoot)(AMRecoveryModeDeviceRef device, int enableAutoBoot);
+  int (*RecoveryDeviceReboot)(AMRecoveryModeDeviceRef device);
+
+  // Services
+  int (*CreateHouseArrestService)(AMDeviceRef device, CFStringRef bundleID, void *_Nullable unused, AFCConnectionRef *connectionOut);
+  int (*LookupApplications)(AMDeviceRef device, CFDictionaryRef _Nullable options, CFDictionaryRef _Nonnull * _Nonnull attributesOut);
+  int (*SecureInstallApplication)(_Nullable AMDServiceConnectionRef connection, AMDeviceRef device, CFURLRef arg2, CFDictionaryRef arg3, _Nullable AMDeviceProgressCallback callback, void *_Nullable context);
+  int (*SecureInstallApplicationBundle)(AMDeviceRef device, CFURLRef hostAppURL, CFDictionaryRef _Nullable options, _Nullable AMDeviceProgressCallback callback, void *_Nullable context);
+  int (*SecureStartService)(AMDeviceRef device, CFStringRef service_name, _Nullable CFDictionaryRef userinfo, CFTypeRef *serviceOut);
+  int (*SecureTransferPath)(_Nullable AMDServiceConnectionRef connection, AMDeviceRef device, CFURLRef arg2, CFDictionaryRef arg3, _Nullable AMDeviceProgressCallback callback, void *_Nullable context);
+  int (*SecureUninstallApplication)(_Nullable AMDServiceConnectionRef connection, AMDeviceRef device, CFStringRef arg2, int arg3, _Nullable AMDeviceProgressCallback callback, void *_Nullable context);
+
+  // Developer Images
+  int (*MountImage)(AMDeviceRef device, CFStringRef image, CFDictionaryRef options, _Nullable AMDeviceProgressCallback callback, void *_Nullable context);
+
+  // Provisioning Profiles
+  CFArrayRef (*CopyProvisioningProfiles)(AMDeviceRef device);
+  CFDictionaryRef (*ProvisioningProfileCopyPayload)(CFTypeRef profile);
+  MISProfileRef (*ProvisioningProfileCreateWithData)(CFDataRef data);
+  int (*InstallProvisioningProfile)(AMDeviceRef device, MISProfileRef profile);
+  int (*RemoveProvisioningProfile)(AMDeviceRef device, CFStringRef profileUUID);
+  CFStringRef (*ProvisioningProfileGetUUID)(MISProfileRef profile);
+  CFStringRef (*ProvisioningProfileCopyErrorStringForCode)(int code);
+
+  // Restorable Devices: Notifications
+  int (*RestorableDeviceRegisterForNotifications)(AMRestorableDeviceNotificationCallback callback, void *context, int arg2, int arg3);
+  int (*RestorableDeviceUnregisterForNotifications)(int registrationID);
+
+  // Restorable Devices: Getting and Copying Values.
+  CFStringRef (*RestorableDeviceCopyBoardConfig)(AMRestorableDeviceRef device);
+  CFStringRef (*RestorableDeviceCopyProductString)(AMRestorableDeviceRef device);
+  CFStringRef (*RestorableDeviceCopySerialNumber)(AMRestorableDeviceRef device);
+  CFStringRef (*RestorableDeviceCopyUserFriendlyName)(AMRestorableDeviceRef device);
+  int (*RestorableDeviceGetBoardID)(AMRestorableDeviceRef device);
+  int (*RestorableDeviceGetChipID)(AMRestorableDeviceRef device);
+  int (*RestorableDeviceGetDeviceClass)(AMRestorableDeviceRef device);
+  unsigned long (*RestorableDeviceGetECID)(AMRestorableDeviceRef device);
+  int (*RestorableDeviceGetLocationID)(AMRestorableDeviceRef device);
+  int (*RestorableDeviceGetProductType)(AMRestorableDeviceRef device);
+  int (*RestorableDeviceGetState)(AMRestorableDeviceRef device);
+
+  // AppleMobileSync
+  int (*AMSInitialize)(int arg0);
+  int (*AMSEraseDevice)(CFStringRef udid, AMSEraseDeviceCallback callback, void *context);
+
+  // USBMux
+  int (*GetConnectionID)(AMDeviceRef device);
+  int (*USBMuxConnectByPort)(int connectionID, int remotePort, int *socket);
+
+  // Debugging
+  void (*InitializeMobileDevice)(void);
+  void (*SetLogLevel)(int32_t level);
+  _Nullable CFStringRef (*CopyErrorText)(int status);
+} AMDCalls;
+
+/**
+ A Structure holding references to the 'Apple File Conduit' APIs we use.
+ */
+typedef struct {
+  // Creating a Connection
+  AFCConnectionRef (*Create)(void *_Nullable unknown0, int socket, void *_Nullable unknown1, AFCNotificationCallback callback, void *_Nullable unknown3);
+  int (*ConnectionOpen)(CFTypeRef handle, uint32_t io_timeout, CFTypeRef _Nullable *_Nullable conn);
+  int (*ConnectionClose)(AFCConnectionRef connection);
+  int (*ConnectionIsValid)(AFCConnectionRef connection);
+  void (*SetSecureContext)(AFCConnectionRef connection, AMSecureIOContext ioContext);
+
+  // Individual Operations
+  int (*DirectoryOpen)(AFCConnectionRef connection, const char *path, CFTypeRef _Nullable * _Nullable dir);
+  int (*DirectoryRead)(AFCConnectionRef connection, CFTypeRef dir, char *_Nullable *_Nullable dirent);
+  int (*DirectoryClose)(AFCConnectionRef connection, CFTypeRef dir);
+  int (*DirectoryCreate)(AFCConnectionRef connection, const char *dir);
+  int (*FileRefOpen)(AFCConnectionRef connection, const char *_Nonnull path, FBAFCReadMode mode, CFTypeRef *_Nonnull ref);
+  int (*FileRefClose)(AFCConnectionRef connection, CFTypeRef ref);
+  int (*FileRefSeek)(AFCConnectionRef connection, CFTypeRef ref, int64_t offset, uint64_t mode);
+  int (*FileRefTell)(AFCConnectionRef connection, CFTypeRef ref, uint64_t *_Nonnull offset);
+  int (*FileRefRead)(AFCConnectionRef connection, CFTypeRef ref, void *_Nonnull buf, uint64_t *_Nonnull len);
+  int (*FileRefWrite)(AFCConnectionRef connection, CFTypeRef ref, const void *_Nonnull buf, uint64_t len);
+  int (*RenamePath)(AFCConnectionRef connection, const char *_Nonnull path, const char *_Nonnull toPath);
+  int (*RemovePath)(AFCConnectionRef connection, const char *_Nonnull path);
+
+  // Batch Operations
+  int (*ConnectionProcessOperation)(AFCConnectionRef connection, CFTypeRef operation);
+  int (*OperationGetResultStatus)(CFTypeRef operation);
+  CFTypeRef (*OperationCreateRemovePathAndContents)(CFTypeRef allocator, CFStringRef path, void *_Nullable unknown_callback_maybe);
+  CFTypeRef (*OperationGetResultObject)(CFTypeRef operation);
+
+  // Errors
+  char *(*ErrorString)(int errorCode);
+  CFDictionaryRef (*ConnectionCopyLastErrorInfo)(AFCConnectionRef connection);
+} AFCCalls;
+
+#pragma clang diagnostic pop

package/vendor/axe/Frameworks/FBDeviceControl.framework/Versions/A/Headers/FBAMDevice.h

@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import <FBControlCore/FBControlCore.h>
+#import <FBDeviceControl/FBAMDefines.h>
+#import <FBDeviceControl/FBDeviceCommands.h>
+
+@class FBAFCConnection;
+@class FBAMDServiceConnection;
+@class FBAMDeviceServiceManager;
+@class FBDeviceType;
+@class FBOSVersion;
+
+/**
+ An Object Wrapper for AMDevice.
+ AMDevice is a Core Foundation Type in the MobileDevice.framework.
+ Some important things that we've learned about AMDevice from experimentation and looking at other open source projects:
+ - AMDevice sessions should be short-lived. They will timeout after 60 seconds causing subsequent usages (e.g. starting house_arrest service) to fail with:
+   0xe800002d (Could not send a message to the device.)
+ - The AMDevice session only needs to be open long enough to initiate the operation that requires the AMDevice object. It can be closed immediately after
+   without waiting for the subsequent operation to finish. E.g. the right sequence of operations for using a service like com.apple.syslog_relay is:
+     AMDeviceConnect
+     AMDeviceStartSession
+     AMDeviceSecureStartService(amdevice, "com.apple.syslog_relay")
+     AMDeviceStopSession
+     AMDeviceDisconnect
+     // Do stuff with syslog service
+     AMDServiceConnectionInvalidate
+    Previously we were keeping the AMDevice session open for the duration of the service operation, which could hit the 60 second timeout for long operations,
+    causing the next operation to use the AMDevice session to fail.
+ - Only one AMDevice session should be open at once. Trying to open another will result in an error that the session is already active. To handle this we
+   let concurrent operations share the AMDevice session and only close it when there are no waiting consumers.
+   - Interestingly, trying to open a session a third time succeeds, so it seems the second attempt might kill off the first session
+ - Starting / stopping the same service on the phone (e.g. house_arrest) many times in a short period will cause the error 0xe800005b (Too many instances of this service are already running.)
+   Because of this, we pool service connections with a short cooldown to avoid reopening the same service repeatedly during bursts of operations using that service (e.g. recursively enumerating a directory)
+ */
+@interface FBAMDevice : NSObject <FBiOSTargetInfo, FBDeviceCommands, FBFutureContextManagerDelegate>
+
+#pragma mark - FBiOSTargetInfo Protocol Members
+// These are implemented in FBAMDevice.m but must be declared explicitly for Swift visibility
+// since the FBiOSTargetInfo protocol is Swift-defined.
+@property (nonnull, nonatomic, readonly, copy) NSString *uniqueIdentifier;
+@property (nonnull, nonatomic, readonly, copy) NSString *udid;
+@property (nonnull, nonatomic, readonly, copy) NSString *name;
+@property (nonnull, nonatomic, readonly, strong) FBDeviceType *deviceType;
+@property (nonnull, nonatomic, readonly, copy) NSArray<FBArchitecture> *architectures;
+@property (nonnull, nonatomic, readonly, strong) FBOSVersion *osVersion;
+@property (nonnull, nonatomic, readonly, copy) NSDictionary<NSString *, id> *extendedInformation;
+@property (nonatomic, readonly, assign) FBiOSTargetType targetType;
+@property (nonatomic, readonly, assign) FBiOSTargetState state;
+
+/**
+ The queue on which work should be serialized.
+ */
+@property (nonnull, nonatomic, readonly, strong) dispatch_queue_t workQueue;
+
+/**
+ The queue on which asynchronous work can be performed sequentially.
+ */
+@property (nonnull, nonatomic, readonly, strong) dispatch_queue_t asyncQueue;
+
+#pragma mark - Should be marked private when converting to Swift
+
+/**
+ The underyling AMDeviceRef.
+ May be NULL.
+ */
+@property (nonatomic, readwrite, assign) AMDeviceRef _Nullable amDeviceRef;
+
+/**
+ All of the Device Values available.
+ */
+@property (nonnull, nonatomic, readwrite, copy) NSDictionary<NSString *, id> *allValues;
+
+/**
+ The Context Manager for the Connection
+ */
+@property (nonnull, nonatomic, readonly, strong) FBFutureContextManager<FBAMDevice *> *connectionContextManager;
+
+/**
+ The Service Manager.
+ */
+@property (nonnull, nonatomic, readonly, strong) FBAMDeviceServiceManager *serviceManager;
+
+/**
+ The Designated Initializer
+
+ @param allValues the values from the AMDevice.
+ @param calls the calls to use.
+ @param connectionReuseTimeout the time to wait before releasing a connection
+ @param serviceReuseTimeout the time to wait before releasing a service
+ @param workQueue the queue on which work should be serialized.
+ @param asyncQueue the queue on which asynchronous work can be performed sequentially.
+ @param logger the logger to use.
+ @return a new FBAMDevice instance.
+ */
+- (nonnull instancetype)initWithAllValues:(nonnull NSDictionary<NSString *, id> *)allValues calls:(AMDCalls)calls connectionReuseTimeout:(nullable NSNumber *)connectionReuseTimeout serviceReuseTimeout:(nullable NSNumber *)serviceReuseTimeout workQueue:(nonnull dispatch_queue_t)workQueue asyncQueue:(nonnull dispatch_queue_t)asyncQueue logger:(nonnull id<FBControlCoreLogger>)logger;
+
+@end

package/vendor/axe/Frameworks/FBDeviceControl.framework/Versions/A/Headers/FBAMDeviceManager.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import <FBDeviceControl/FBAMDefines.h>
+#import <FBDeviceControl/FBDeviceManager.h>
+
+@class FBAMDevice;
+
+/**
+ Class for obtaining FBAMDevice instances.
+ */
+@interface FBAMDeviceManager : FBDeviceManager <FBAMDevice *>
+
+/**
+ The Designated Initializer
+
+ @param calls the AMDCalls to use.
+ @param workQueue the queue on which work should be serialized.
+ @param asyncQueue the queue on which asynchronous work can be performed sequentially.
+ @param ecidFilter an ECID filter to apply, or `nil` to accept all devices.
+ @param logger the logger to use.
+ @return a new FBAMDeviceManager instance
+ */
+- (nonnull instancetype)initWithCalls:(AMDCalls)calls workQueue:(nonnull dispatch_queue_t)workQueue asyncQueue:(nonnull dispatch_queue_t)asyncQueue ecidFilter:(nullable NSString *)ecidFilter logger:(nonnull id<FBControlCoreLogger>)logger;
+
+/**
+ Starts using the AMDeviceRef by doing the following:
+ - Starts a Connection with the device
+ - Performing and validating pairing.
+ - Starts a session.
+
+ @param device the device to use.
+ @param calls the calls to use.
+ @param logger the logger to use.
+ @param error an error out for any error that occurs.
+ @return YES if successful, NO otherwise.
+ */
++ (BOOL)startUsing:(AMDeviceRef _Nonnull)device calls:(AMDCalls)calls logger:(nonnull id<FBControlCoreLogger>)logger error:(NSError * _Nullable * _Nullable)error;
+
+/**
+ Stops using the AMDeviceRef connections.
+ - Stops the session with the device.
+ - Stops the connection with the device.
+
+ @param device the device to use.
+ @param calls the calls to use.
+ @param logger the logger to use.
+ @param error an error out for any error that occurs.
+ @return YES if successful, NO otherwise.
+ */
++ (BOOL)stopUsing:(AMDeviceRef _Nonnull)device calls:(AMDCalls)calls logger:(nonnull id<FBControlCoreLogger>)logger error:(NSError * _Nullable * _Nullable)error;
+
+@end