@ansight/react-native 1.3.0-preview.9 → 1.4.0-preview.3

package/ios/AnsightReactNative.swift

@@ -137,8 +137,56 @@ final class AnsightReactNative: RCTEventEmitter {
         }
     }
 
+    private final class ReactNativeVisualTreeProvider: AnsightVisualTreeProvider, AnsightVisualTreeInteractionProvider, @unchecked Sendable {
+        let source = "react"
+        let displayName = "React Native"
+        private weak var module: AnsightReactNative?
+        private let timeoutMilliseconds: Int
+
+        init(module: AnsightReactNative, timeoutMilliseconds: Int) {
+            self.module = module
+            self.timeoutMilliseconds = timeoutMilliseconds
+        }
+
+        func getVisualTree(arguments: [String: String]) -> AnsightToolExecutionResult {
+            module?.executeJavaScriptTool(
+                toolId: "react.get_component_tree",
+                arguments: arguments,
+                timeoutMilliseconds: timeoutMilliseconds
+            ) ?? .failure("React Native bridge is unavailable.", errorCode: "javascript_bridge_unavailable")
+        }
+
+        func inspectNode(arguments: [String: String]) -> AnsightToolExecutionResult {
+            module?.executeJavaScriptTool(
+                toolId: "react.get_component",
+                arguments: arguments,
+                timeoutMilliseconds: timeoutMilliseconds
+            ) ?? .failure("React Native bridge is unavailable.", errorCode: "javascript_bridge_unavailable")
+        }
+
+        func performAction(_ request: AnsightVisualTreeActionRequest) -> AnsightToolExecutionResult {
+            let prop: String
+            switch request.action.lowercased() {
+            case "tap": prop = "onPress"
+            case "focus": prop = "onFocus"
+            case "setvalue", "typetext": prop = "onChangeText"
+            case "toggle": prop = "onValueChange"
+            default:
+                if case .string(let configured)? = request.options["prop"] { prop = configured } else { prop = request.action }
+            }
+            var arguments = ["nodeId": request.nodeId, "prop": prop]
+            if let value = request.value?.stringValue { arguments["value"] = value }
+            return module?.executeJavaScriptTool(
+                toolId: "react.invoke_component_action",
+                arguments: arguments,
+                timeoutMilliseconds: timeoutMilliseconds
+            ) ?? .failure("React Native bridge is unavailable.", errorCode: "javascript_bridge_unavailable")
+        }
+    }
+
     private let lock = NSLock()
     private var hasListeners = false
+    private var hostConnectionStatusSubscription: HostConnectionStatusSubscription?
     private var activeCustomToolIds: Set<String> = []
     private var pendingToolCalls: [String: PendingToolCall] = [:]
     private var reactNativeMemorySampler: ReactNativeMemorySamplerBox?
@@ -150,10 +198,14 @@ final class AnsightReactNative: RCTEventEmitter {
     override init() {
         super.init()
         AnsightLogger.registerCallback(logCallback)
+        hostConnectionStatusSubscription = AnsightRuntime.shared.addHostConnectionStatusListener { [weak self] status, _ in
+            self?.emitHostConnectionStatusEvent(status)
+        }
     }
 
     deinit {
         AnsightLogger.removeCallback(logCallback)
+        hostConnectionStatusSubscription?.remove()
     }
 
     override static func requiresMainQueueSetup() -> Bool {
@@ -161,7 +213,7 @@ final class AnsightReactNative: RCTEventEmitter {
     }
 
     override func supportedEvents() -> [String]! {
-        ["AnsightToolCall", "AnsightLog"]
+        ["AnsightToolCall", "AnsightLog", "AnsightHostConnectionStatus"]
     }
 
     override func startObserving() {
@@ -292,6 +344,27 @@ final class AnsightReactNative: RCTEventEmitter {
         }
     }
 
+    @objc(recordNetworkRequest:resolver:rejecter:)
+    func recordNetworkRequest(
+        _ input: NSDictionary,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        guard JSONSerialization.isValidJSONObject(input),
+              let data = try? JSONSerialization.data(withJSONObject: input),
+              let request = try? JSONDecoder().decode(AnsightNetworkRequest.self, from: data),
+              request.schema == AnsightNetworkRequest.schemaName
+        else {
+            resolve(operationResultDictionary(
+                .failure("Network request must use the ansight.network-request.v1 schema.")
+            ))
+            return
+        }
+        Task {
+            resolve(operationResultDictionary(await AnsightRuntime.shared.recordNetworkRequest(request)))
+        }
+    }
+
     @objc(recordCrashCandidate:resolver:rejecter:)
     func recordCrashCandidate(
         _ input: NSDictionary,
@@ -676,6 +749,12 @@ final class AnsightReactNative: RCTEventEmitter {
                 ReactNativeTool(descriptor: descriptor, module: self, timeoutMilliseconds: timeout),
                 replaceExisting: true
             )
+            if descriptor.id == "react.get_component_tree" {
+                try AnsightVisualTreeProviderRegistry.register(
+                    ReactNativeVisualTreeProvider(module: self, timeoutMilliseconds: timeout),
+                    replaceExisting: true
+                )
+            }
             resolve(["id": descriptor.id, "registered": true])
         } catch {
             reject("ansight_error", error.localizedDescription, error)
@@ -859,6 +938,17 @@ final class AnsightReactNative: RCTEventEmitter {
         }
     }
 
+    private func emitHostConnectionStatusEvent(_ status: HostConnectionStatus) {
+        let shouldEmit = lock.withLock { hasListeners }
+        guard shouldEmit else { return }
+        DispatchQueue.main.async {
+            self.sendEvent(
+                withName: "AnsightHostConnectionStatus",
+                body: self.hostConnectionStatusDictionary(status)
+            )
+        }
+    }
+
     private func configureReactNativeMemoryProfiling(_ dictionary: NSDictionary?) throws {
         let options = ReactNativeMemoryProfilingOptions(dictionary: dictionary)
         currentReactNativeMemoryOptions = options
@@ -1137,11 +1227,11 @@ final class AnsightReactNative: RCTEventEmitter {
             name: stringValue(dictionary, "name") ?? stringValue(dictionary, "id") ?? "",
             description: stringValue(dictionary, "description") ?? "",
             category: stringValue(dictionary, "category") ?? "custom",
-            scope: toolScope(stringValue(dictionary, "scope")).rawValue,
+            policy: toolPolicy(stringValue(dictionary, "policy")),
             keywords: keywords(dictionary["keywords"]),
-            security: toolSecurity(dictionary["security"] as? NSDictionary),
             argumentsSchema: AnsightToolSchema(json: jsonValue(dictionary["argumentsSchema"]) ?? .object([:])),
-            resultSchema: AnsightToolSchema(json: jsonValue(dictionary["resultSchema"]) ?? .object([:]))
+            resultSchema: AnsightToolSchema(json: jsonValue(dictionary["resultSchema"]) ?? .object([:])),
+            prerequisiteToolIds: stringArray(dictionary, "prerequisiteToolIds")
         )
     }
 
@@ -1647,41 +1737,17 @@ private func toolGuard(_ rawValue: String) -> AnsightToolGuard {
     }
 }
 
-private func toolScope(_ rawValue: String?) -> AnsightToolScope {
+private func toolPolicy(_ rawValue: String?) -> AnsightToolPolicy {
     switch rawValue?.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() {
     case "write":
         return .write
-    case "delete":
-        return .delete
+    case "critical", "delete":
+        return .critical
     default:
         return .read
     }
 }
 
-private func toolSecurity(_ dictionary: NSDictionary?) -> AnsightToolSecurity {
-    guard let dictionary else {
-        return .unspecified
-    }
-    let level: AnsightToolSecurityLevel
-    switch stringValue(dictionary, "level")?.lowercased() {
-    case "low":
-        level = .low
-    case "medium", "moderate":
-        level = .moderate
-    case "high":
-        level = .high
-    case "critical":
-        level = .critical
-    default:
-        level = .unspecified
-    }
-    return AnsightToolSecurity(
-        level: level,
-        summary: stringValue(dictionary, "summary") ?? "",
-        implications: (dictionary["implications"] as? [Any])?.compactMap { $0 as? String } ?? []
-    )
-}
-
 private func keywords(_ value: Any?) -> String {
     if let string = value as? String {
         return string

package/ios/AnsightReactNativeModule.m

@@ -33,6 +33,10 @@ RCT_EXTERN_METHOD(recordEvent:(NSDictionary *)input
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(recordNetworkRequest:(NSDictionary *)input
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(recordCrashCandidate:(NSDictionary *)input
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)