mcp-baepsae 5.1.0 → 6.2.0

package/native/Sources/IndigoHID/IndigoHIDCoordinates.swift

@@ -0,0 +1,74 @@
+import CoreGraphics
+import Foundation
+
+// MARK: - Coordinate Normalization
+
+/// Normalizes pixel coordinates to 0-1 ratio for IndigoHID.
+/// IndigoHID expects coordinates as fractions of the screen dimensions.
+struct IndigoHIDCoordinates {
+    let screenWidth: Double
+    let screenHeight: Double
+
+    init(screenWidth: Double, screenHeight: Double) {
+        self.screenWidth = max(1, screenWidth)
+        self.screenHeight = max(1, screenHeight)
+    }
+
+    /// Convert point coordinates (pixels) to normalized 0-1 ratio.
+    /// Origin is top-left.
+    func normalize(x: Double, y: Double) -> (x: Double, y: Double) {
+        return (x / screenWidth, y / screenHeight)
+    }
+
+    /// Create a touch point from pixel coordinates.
+    func touchPoint(x: Double, y: Double, phase: IndigoHIDTouchPhase, finger: UInt32 = 1) -> IndigoHIDTouchPoint {
+        let (nx, ny) = normalize(x: x, y: y)
+        return IndigoHIDTouchPoint(x: nx, y: ny, phase: phase, finger: finger)
+    }
+}
+
+/// Resolve screen dimensions for the given simulator UDID.
+/// Falls back to common iPhone dimensions if detection fails.
+func resolveSimulatorScreenSize(udid: String) -> (width: Double, height: Double) {
+    // Try to get screen size from simctl
+    let process = Process()
+    process.executableURL = URL(fileURLWithPath: "/usr/bin/xcrun")
+    process.arguments = ["simctl", "list", "devices", "-j"]
+
+    let pipe = Pipe()
+    process.standardOutput = pipe
+    process.standardError = FileHandle.nullDevice
+
+    do {
+        try process.run()
+        process.waitUntilExit()
+
+        let data = pipe.fileHandleForReading.readDataToEndOfFile()
+        if let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+           let devices = json["devices"] as? [String: [[String: Any]]] {
+            for (_, deviceList) in devices {
+                for device in deviceList {
+                    if let deviceUdid = device["udid"] as? String, deviceUdid == udid {
+                        // Try to infer from device type
+                        if let deviceType = device["deviceTypeIdentifier"] as? String {
+                            if deviceType.contains("iPhone-16") || deviceType.contains("iPhone-15") {
+                                return (393, 852)
+                            }
+                            if deviceType.contains("iPhone-SE") {
+                                return (375, 667)
+                            }
+                            if deviceType.contains("iPad") {
+                                return (1024, 1366)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    } catch {
+        // Fall through to default
+    }
+
+    // Default: iPhone 15/16 logical resolution
+    return (393, 852)
+}

package/native/Sources/IndigoHID/IndigoHIDEvents.swift

@@ -0,0 +1,63 @@
+@preconcurrency import Foundation
+
+// bootstrap_look_up is in /usr/include/servers/bootstrap.h
+@_silgen_name("bootstrap_look_up")
+func _bootstrap_look_up(_ bp: mach_port_t, _ name: UnsafePointer<CChar>, _ sp: UnsafeMutablePointer<mach_port_t>) -> kern_return_t
+
+// MARK: - Mach Port Communication
+
+/// Resolves the IndigoHID Mach service port for a given simulator UDID.
+func resolveIndigoHIDPort(udid: String) -> mach_port_t? {
+    let serviceName = "com.apple.CoreSimulator.IndigoHIDService.\(udid)"
+    var port: mach_port_t = mach_port_t(MACH_PORT_NULL)
+    let bp = mach_port_t(bootstrap_port)
+    let result = serviceName.withCString { cStr in
+        _bootstrap_look_up(bp, cStr, &port)
+    }
+    if result == KERN_SUCCESS && port != mach_port_t(MACH_PORT_NULL) {
+        return port
+    }
+    return nil
+}
+
+/// Sends an IndigoHID message to the simulator via Mach IPC.
+func sendIndigoHIDMessage(_ data: CFData, to port: mach_port_t) -> Bool {
+    let bytes = CFDataGetBytePtr(data)
+    let length = CFDataGetLength(data)
+    guard let bytes, length > 0 else { return false }
+
+    // Construct mach message
+    let headerSize = MemoryLayout<mach_msg_header_t>.size
+    let totalSize = headerSize + length
+    let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: totalSize)
+    defer { buffer.deallocate() }
+
+    // Zero out buffer
+    buffer.initialize(repeating: 0, count: totalSize)
+
+    // Set up mach message header
+    buffer.withMemoryRebound(to: mach_msg_header_t.self, capacity: 1) { header in
+        header.pointee.msgh_bits = UInt32(MACH_MSG_TYPE_COPY_SEND)
+        header.pointee.msgh_size = mach_msg_size_t(totalSize)
+        header.pointee.msgh_remote_port = port
+        header.pointee.msgh_local_port = mach_port_t(MACH_PORT_NULL)
+        header.pointee.msgh_id = 0
+    }
+
+    // Copy payload after header
+    (buffer + headerSize).update(from: bytes, count: length)
+
+    let result = buffer.withMemoryRebound(to: mach_msg_header_t.self, capacity: 1) { header in
+        mach_msg(
+            header,
+            MACH_SEND_MSG,
+            mach_msg_size_t(totalSize),
+            0,
+            mach_port_t(MACH_PORT_NULL),
+            MACH_MSG_TIMEOUT_NONE,
+            mach_port_t(MACH_PORT_NULL)
+        )
+    }
+
+    return result == KERN_SUCCESS
+}

package/native/Sources/IndigoHID/IndigoHIDLoader.swift

@@ -0,0 +1,102 @@
+import Foundation
+
+// MARK: - Symbol Types
+
+// Function pointer types matching SimulatorKit's IndigoHID API
+typealias IndigoHIDMessageForButtonFn = @convention(c) (
+    UInt32,  // button type
+    UInt32,  // state (1=down, 2=up)
+    UInt64   // timestamp
+) -> Unmanaged<CFData>?
+
+typealias IndigoHIDMessageForKeyboardArbitraryFn = @convention(c) (
+    UInt32,  // usage page
+    UInt32,  // usage (key code)
+    UInt32,  // key operation (1=down, 2=up)
+    UInt64   // timestamp
+) -> Unmanaged<CFData>?
+
+typealias IndigoHIDMessageForMouseNSEventFn = @convention(c) (
+    UInt32,  // touch phase
+    Double,  // x (0-1 normalized)
+    Double,  // y (0-1 normalized)
+    UInt32,  // finger index
+    Double,  // pressure
+    Double,  // twist
+    Double,  // major radius
+    Double,  // minor radius
+    UInt64   // timestamp
+) -> Unmanaged<CFData>?
+
+// MARK: - IndigoHID Loader
+
+/// Loads IndigoHID symbols from SimulatorKit.framework via dlopen/dlsym.
+/// This is a singleton — symbol loading happens once.
+final class IndigoHIDLoader: @unchecked Sendable {
+    static let shared = IndigoHIDLoader()
+
+    let buttonFn: IndigoHIDMessageForButtonFn?
+    let keyboardFn: IndigoHIDMessageForKeyboardArbitraryFn?
+    let mouseFn: IndigoHIDMessageForMouseNSEventFn?
+
+    /// Whether all required symbols were loaded successfully.
+    var isAvailable: Bool {
+        return buttonFn != nil && keyboardFn != nil && mouseFn != nil
+    }
+
+    private init() {
+        let frameworkPath = "/Library/Developer/PrivateFrameworks/CoreSimulator.framework/Versions/A/Frameworks/SimulatorKit.framework/SimulatorKit"
+        let alternativePath = "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Library/Developer/CoreSimulator/Profiles/Runtimes/iOS.simruntime/Contents/Resources/RuntimeRoot/System/Library/PrivateFrameworks/SimulatorKit.framework/SimulatorKit"
+
+        var handle = dlopen(frameworkPath, RTLD_LAZY)
+        if handle == nil {
+            handle = dlopen(alternativePath, RTLD_LAZY)
+        }
+
+        guard let handle else {
+            self.buttonFn = nil
+            self.keyboardFn = nil
+            self.mouseFn = nil
+            return
+        }
+
+        if let sym = dlsym(handle, "IndigoHIDMessageForButton") {
+            self.buttonFn = unsafeBitCast(sym, to: IndigoHIDMessageForButtonFn.self)
+        } else {
+            self.buttonFn = nil
+        }
+
+        if let sym = dlsym(handle, "IndigoHIDMessageForKeyboardArbitrary") {
+            self.keyboardFn = unsafeBitCast(sym, to: IndigoHIDMessageForKeyboardArbitraryFn.self)
+        } else {
+            self.keyboardFn = nil
+        }
+
+        if let sym = dlsym(handle, "IndigoHIDMessageForMouseNSEvent") {
+            self.mouseFn = unsafeBitCast(sym, to: IndigoHIDMessageForMouseNSEventFn.self)
+        } else {
+            self.mouseFn = nil
+        }
+    }
+
+    /// Create a touch event message.
+    func createTouchMessage(phase: IndigoHIDTouchPhase, x: Double, y: Double, finger: UInt32 = 1) -> CFData? {
+        guard let fn = mouseFn else { return nil }
+        let timestamp = mach_absolute_time()
+        return fn(phase.rawValue, x, y, finger, 1.0, 0.0, 5.0, 5.0, timestamp)?.takeRetainedValue()
+    }
+
+    /// Create a button event message.
+    func createButtonMessage(button: IndigoHIDButtonEventType, state: UInt32) -> CFData? {
+        guard let fn = buttonFn else { return nil }
+        let timestamp = mach_absolute_time()
+        return fn(button.rawValue, state, timestamp)?.takeRetainedValue()
+    }
+
+    /// Create a keyboard event message.
+    func createKeyboardMessage(usagePage: UInt32, usage: UInt32, operation: IndigoHIDKeyOperation) -> CFData? {
+        guard let fn = keyboardFn else { return nil }
+        let timestamp = mach_absolute_time()
+        return fn(usagePage, usage, operation.rawValue, timestamp)?.takeRetainedValue()
+    }
+}

package/native/Sources/IndigoHID/IndigoHIDTypes.swift

@@ -0,0 +1,41 @@
+import Foundation
+
+// MARK: - Touch Phase
+
+enum IndigoHIDTouchPhase: UInt32 {
+    case began = 1
+    case moved = 2
+    case ended = 4
+}
+
+// MARK: - Button Event Type
+
+enum IndigoHIDButtonEventType: UInt32 {
+    case home = 1
+    case lock = 2
+    case siri = 3
+    case applePay = 4
+}
+
+// MARK: - Key Operation
+
+enum IndigoHIDKeyOperation: UInt32 {
+    case keyDown = 1
+    case keyUp = 2
+}
+
+// MARK: - Touch Point
+
+struct IndigoHIDTouchPoint {
+    let x: Double  // 0.0 - 1.0 normalized
+    let y: Double  // 0.0 - 1.0 normalized
+    let phase: IndigoHIDTouchPhase
+    let finger: UInt32
+
+    init(x: Double, y: Double, phase: IndigoHIDTouchPhase, finger: UInt32 = 1) {
+        self.x = max(0, min(1, x))
+        self.y = max(0, min(1, y))
+        self.phase = phase
+        self.finger = finger
+    }
+}

package/native/Sources/Types.swift

@@ -26,6 +26,32 @@ enum NativeError: Error, CustomStringConvertible {
     }
 }
 
+enum NativeErrorCode: String {
+    case invalidArguments = "invalid_arguments"
+    case unsupported = "unsupported"
+    case commandFailed = "command_failed"
+}
+
+enum NativeErrorCategory: String {
+    case validation
+    case execution
+    case environment
+    case permission
+    case unsupported
+    case availability
+    case timeout
+    case unknown
+}
+
+struct StructuredNativeError {
+    let code: String
+    let category: NativeErrorCategory
+    let retryable: Bool
+    let source: String
+    let message: String
+    let nativeCode: NativeErrorCode
+}
+
 struct ParsedOptions {
     let command: String
     let options: [String: String]