mobridge-mcp 0.0.1

package/resources/ios/MobileSemantic/UITests/BridgeServer.swift

@@ -0,0 +1,216 @@
+import Foundation
+import XCTest
+import Darwin
+
+// The XCTest Runner (WDA-style): a long-running UI test that binds a TCP socket on 127.0.0.1:8500 and
+// services length-prefixed JSON-RPC requests by doing REAL XCUIApplication/XCUIElement work. TS stays
+// the source of truth for NodeRef resolution + VerificationPolicy; this Runner only captures fresh
+// snapshots, double-checks the candidate count, performs the native action, and returns before/after.
+//
+// Framing (frozen, matches PROTOCOL.md + bridgeTransport.ts): 4-byte big-endian length + UTF-8 JSON.
+final class BridgeServer: XCTestCase {
+
+    private static let port: UInt16 = 8500
+    private let runnerInstanceId = UUID().uuidString
+    private var sessionToken = ""
+    private var app: XCUIApplication!
+    // The bundle id of the app currently under automation. nil = the default test-host target (fixture).
+    // app.open with a `bundleId` switches this to any already-installed app (XCUIApplication(bundleIdentifier:)),
+    // so CMS can read/act on App Store / system apps without re-signing them; only this Runner is signed.
+    private var targetBundleId: String? = nil
+
+    func testServe() throws {
+        continueAfterFailure = true
+        app = XCUIApplication()
+        app.launch()
+
+        let listenFd = try openListener(port: BridgeServer.port)
+        defer { close(listenFd) }
+        FileHandle.standardError.write("[runner] listening on 127.0.0.1:\(BridgeServer.port)\n".data(using: .utf8)!)
+
+        while true {
+            let fd = accept(listenFd, nil, nil)
+            if fd < 0 { continue }
+            var shutdown = false
+            while !shutdown, let req = readFrame(fd) {
+                let (resp, stop) = handle(req)
+                writeFrame(fd, resp)
+                shutdown = stop
+            }
+            close(fd)
+            if shutdown { break }
+        }
+    }
+
+    // MARK: dispatch
+
+    private func handle(_ req: [String: Any]) -> ([String: Any], Bool) {
+        let requestId = req["requestId"] as? Int ?? 0
+        let method = req["method"] as? String ?? ""
+        let params = req["params"] as? [String: Any] ?? [:]
+
+        func ok(_ result: [String: Any]) -> ([String: Any], Bool) {
+            ([ "requestId": requestId, "runnerInstanceId": runnerInstanceId, "sessionToken": sessionToken, "result": result ], false)
+        }
+        func err(_ code: String, _ msg: String, _ rec: [String] = []) -> ([String: Any], Bool) {
+            ([ "requestId": requestId, "runnerInstanceId": runnerInstanceId, "sessionToken": sessionToken,
+               "error": ["error": code, "message": msg, "recovery": rec] ], false)
+        }
+
+        switch method {
+        case "HELLO":
+            sessionToken = params["sessionToken"] as? String ?? UUID().uuidString
+            return ok(["protocolVersion": 1, "runnerInstanceId": runnerInstanceId, "sessionToken": sessionToken, "maxPayloadBytes": 16 * 1024 * 1024, "runnerState": "READY"])
+        case "PING":
+            return ok(["pong": true])
+        case "SHUTDOWN":
+            return ([ "requestId": requestId, "result": ["bye": true] ], true)
+        case "device.connect":
+            return ok(["deviceId": params["deviceId"] as? String ?? "ios-sim", "sessionId": runnerInstanceId, "capabilities": ["screen.get", "screen.find", "screen.act", "screen.wait", "screen.diff"]])
+        case "app.open":
+            return appOpen(params, ok: ok, err: err)
+        case "screen.get":
+            return ok(snapshot())
+        case "screen.act":
+            return screenAct(params, ok: ok, err: err)
+        case "system.action":
+            let a = params["action"] as? String ?? ""
+            // rc.2: DISPATCH + evidence only. HOME is business-level with no intrinsic predicate; the
+            // Runner never self-reports a verdict — TS is the sole verifier.
+            if a == "HOME" {
+                let before = snapshot()
+                XCUIDevice.shared.press(.home)
+                return ok(["dispatch": ["status": "DISPATCHED", "method": "GLOBAL_KEY"], "before": before, "after": snapshot()])
+            }
+            return err("ACTION_UNSUPPORTED", "system.action '\(a)' is not supported on iOS.", ["iOS BACK/RECENTS are not global actions."])
+        default:
+            return err("ACTION_UNSUPPORTED", "Unknown bridge method '\(method)'.", ["See PROTOCOL.md."])
+        }
+    }
+
+    private func isValidBundleId(_ b: String) -> Bool {
+        // reverse-DNS-ish: segments of [A-Za-z0-9-] joined by dots; guards against argv/format injection.
+        guard b.count <= 255 else { return false }
+        return b.range(of: "^[A-Za-z0-9][A-Za-z0-9-]*(\\.[A-Za-z0-9][A-Za-z0-9-]*)+$", options: .regularExpression) != nil
+    }
+
+    private func snapshot() -> [String: Any] {
+        let bundle = targetBundleId ?? (Bundle.main.bundleIdentifier ?? "fixture")
+        if let snap = try? app.snapshot() {
+            return Xcui.toScreenSnapshot(snap, bundleId: bundle, deviceId: "ios-sim")
+        }
+        return ["schemaVersion": 1, "platform": "IOS", "nodes": [], "treeHash": "0", "packageName": bundle, "appId": bundle, "snapshotId": "s_empty", "deviceId": "ios-sim", "windowId": 0, "orientation": "portrait", "screenStateId": "ios:0", "compact": true, "timestamp": ISO8601DateFormatter().string(from: Date())]
+    }
+
+    private func appOpen(_ p: [String: Any], ok: ([String: Any]) -> ([String: Any], Bool), err: (String, String, [String]) -> ([String: Any], Bool)) -> ([String: Any], Bool) {
+        let before = snapshot()
+        let action = p["appAction"] as? String ?? "APP_OPEN"
+        // Optional target switch: drive any already-installed app by bundle id (no re-signing of the target).
+        if let bundleId = (p["bundleId"] as? String), !bundleId.isEmpty {
+            guard isValidBundleId(bundleId) else {
+                return err("ACTION_REJECTED", "Invalid bundleId '\(bundleId)'.", ["Pass a valid iOS bundle identifier, e.g. com.apple.Preferences."])
+            }
+            if bundleId != targetBundleId {
+                app = XCUIApplication(bundleIdentifier: bundleId)
+                targetBundleId = bundleId
+            }
+        }
+        switch action {
+        case "APP_OPEN", "APP_BRING_TO_FRONT": app.activate()   // launches the target if not already running
+        case "APP_CLOSE_UI": XCUIDevice.shared.press(.home)
+        default: break
+        }
+        // rc.2: DISPATCH + before/after only. TS applies the intrinsic PACKAGE_CHANGED postcondition.
+        return ok(["dispatch": ["status": "DISPATCHED", "method": "ACCESSIBILITY_ACTION"], "before": before, "after": snapshot()])
+    }
+
+    // TS has already resolved the NodeRef; the Runner re-queries by the resolved locator, double-checks
+    // the count (defence in depth), performs the verb, and returns before/after snapshots.
+    private func screenAct(_ p: [String: Any], ok: ([String: Any]) -> ([String: Any], Bool), err: (String, String, [String]) -> ([String: Any], Bool)) -> ([String: Any], Bool) {
+        let before = snapshot()
+        let verb = p["verb"] as? String ?? "CLICK"
+        let query: XCUIElementQuery
+        if let aid = p["automationId"] as? String, !aid.isEmpty {
+            query = app.descendants(matching: .any).matching(identifier: aid)
+        } else if let label = p["label"] as? String, !label.isEmpty {
+            query = app.descendants(matching: .any).matching(NSPredicate(format: "label == %@", label))
+        } else {
+            return err("NODE_NOT_FOUND", "screen.act needs automationId or label.", ["Resolve a NodeRef first."])
+        }
+        let count = query.count
+        if count == 0 { return err("NODE_NOT_FOUND", "No element matched on the live screen.", ["Re-read screen.get."]) }
+        if count > 1 { return err("AMBIGUOUS_MATCH", "\(count) elements matched; refusing to guess.", ["Use a stronger locator (automationId)."]) }
+        let el = query.element
+        guard el.waitForExistence(timeout: 3) else { return err("NODE_NOT_FOUND", "Element did not become resolvable.", []) }
+        switch verb {
+        case "SET_TEXT":
+            el.tap()
+            // Clear any existing content first so SET_TEXT is a replace, not an append.
+            if let cur = el.value as? String, !cur.isEmpty {
+                el.typeText(String(repeating: XCUIKeyboardKey.delete.rawValue, count: cur.count))
+            }
+            el.typeText(p["value"] as? String ?? "")
+        case "CLEAR_TEXT":
+            el.tap()
+            if let cur = el.value as? String, !cur.isEmpty {
+                el.typeText(String(repeating: XCUIKeyboardKey.delete.rawValue, count: cur.count))
+            }
+        default:
+            el.tap()
+        }
+        // Let the UI settle (SwiftUI re-render) before the after-snapshot, mirroring Android waitStable.
+        Thread.sleep(forTimeInterval: 0.4)
+        return ok(["before": before, "after": snapshot(), "evidence": ["screenChanged": true]])
+    }
+
+    // MARK: sockets (length-prefixed framing)
+
+    private func openListener(port: UInt16) throws -> Int32 {
+        let fd = socket(AF_INET, SOCK_STREAM, 0)
+        guard fd >= 0 else { throw NSError(domain: "runner", code: 1) }
+        var yes: Int32 = 1
+        setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, socklen_t(MemoryLayout<Int32>.size))
+        var addr = sockaddr_in()
+        addr.sin_family = sa_family_t(AF_INET)
+        addr.sin_port = port.bigEndian
+        addr.sin_addr.s_addr = inet_addr("127.0.0.1")
+        let bound = withUnsafePointer(to: &addr) { $0.withMemoryRebound(to: sockaddr.self, capacity: 1) { bind(fd, $0, socklen_t(MemoryLayout<sockaddr_in>.size)) } }
+        guard bound == 0 else { close(fd); throw NSError(domain: "runner", code: 2) }
+        guard listen(fd, 1) == 0 else { close(fd); throw NSError(domain: "runner", code: 3) }
+        return fd
+    }
+
+    private func readN(_ fd: Int32, _ n: Int) -> Data? {
+        var out = Data(); out.reserveCapacity(n)
+        var buf = [UInt8](repeating: 0, count: 65536)
+        while out.count < n {
+            let want = min(n - out.count, buf.count)
+            let r = recv(fd, &buf, want, 0)
+            if r <= 0 { return nil }
+            out.append(contentsOf: buf[0..<r])
+        }
+        return out
+    }
+
+    private func readFrame(_ fd: Int32) -> [String: Any]? {
+        guard let lenData = readN(fd, 4) else { return nil }
+        let len = lenData.withUnsafeBytes { $0.load(as: UInt32.self).bigEndian }
+        guard len > 0, len <= 16 * 1024 * 1024, let body = readN(fd, Int(len)) else { return nil }
+        return (try? JSONSerialization.jsonObject(with: body)) as? [String: Any]
+    }
+
+    private func writeFrame(_ fd: Int32, _ obj: [String: Any]) {
+        guard let body = try? JSONSerialization.data(withJSONObject: obj) else { return }
+        var len = UInt32(body.count).bigEndian
+        var frame = Data(bytes: &len, count: 4); frame.append(body)
+        frame.withUnsafeBytes { raw in
+            var off = 0
+            let base = raw.bindMemory(to: UInt8.self).baseAddress!
+            while off < frame.count {
+                let w = send(fd, base + off, frame.count - off, 0)
+                if w <= 0 { break }
+                off += w
+            }
+        }
+    }
+}

package/resources/ios/MobileSemantic/UITests/XcuiSnapshot.swift

@@ -0,0 +1,73 @@
+import Foundation
+import XCTest
+
+// Real XCUIElementSnapshot -> platform-neutral ScreenSnapshot (protocol/schemas). This is the
+// production mapper (the Sources/MsmSupervisor/SnapshotModel.swift copy is the no-XCTest stand-in).
+enum Xcui {
+
+    static func role(for type: XCUIElement.ElementType) -> String {
+        switch type {
+        case .button: return "BUTTON"
+        case .staticText: return "TEXT"
+        case .textField, .secureTextField, .searchField: return "INPUT"
+        case .image: return "IMAGE"
+        case .checkBox: return "CHECKBOX"
+        case .radioButton: return "RADIO"
+        case .switch, .toggle: return "SWITCH"
+        case .tab, .tabBar: return "TAB"
+        case .link: return "LINK"
+        case .slider: return "SLIDER"
+        case .progressIndicator: return "PROGRESS"
+        case .table, .collectionView: return "LIST"
+        case .cell: return "LIST_ITEM"
+        case .webView: return "WEB_VIEW"
+        case .window, .application: return "SCREEN"
+        case .sheet, .alert, .dialog: return "DIALOG"
+        default: return "UNKNOWN"
+        }
+    }
+
+    /// FNV-1a over the ordered node signatures — parity with the Android collector's treeHash.
+    static func treeHash(_ nodes: [[String: Any]]) -> String {
+        let sig = nodes.map { n in
+            [n["role"] as? String ?? "", n["label"] as? String ?? "", n["value"] as? String ?? "",
+             n["automationId"] as? String ?? "", (n["bounds"] as? [Int])?.map(String.init).joined(separator: ",") ?? ""].joined(separator: "|")
+        }.joined(separator: "\n")
+        var h: UInt32 = 2166136261
+        for b in sig.utf8 { h = (h ^ UInt32(b)) &* 16777619 }
+        return String(format: "%08x", h)
+    }
+
+    static func toScreenSnapshot(_ root: XCUIElementSnapshot, bundleId: String, deviceId: String) -> [String: Any] {
+        var nodes: [[String: Any]] = []
+        var counter = 0
+        func walk(_ el: XCUIElementSnapshot, parentId: String?) {
+            let id = "n\(counter)"; counter += 1
+            let f = el.frame
+            var node: [String: Any] = [
+                "nodeId": id,
+                "role": role(for: el.elementType),
+                "nativeType": "XCUIElementType\(el.elementType.rawValue)",
+            ]
+            if let p = parentId { node["parentId"] = p } else { node["parentId"] = NSNull() }
+            let ident = el.identifier
+            if !ident.isEmpty { node["automationId"] = ident; node["resourceId"] = ident }
+            if !el.label.isEmpty { node["label"] = el.label }
+            if let v = el.value as? String, !v.isEmpty { node["value"] = v }
+            node["bounds"] = [Int(f.minX), Int(f.minY), Int(f.maxX), Int(f.maxY)]
+            let isSecure = el.elementType == .secureTextField
+            node["state"] = ["enabled": el.isEnabled, "selected": el.isSelected, "password": isSecure]
+            nodes.append(node)
+            for c in el.children { walk(c, parentId: id) }
+        }
+        walk(root, parentId: nil)
+        let th = treeHash(nodes)
+        return [
+            "schemaVersion": 1, "platform": "IOS", "deviceId": deviceId,
+            "snapshotId": "s_\(UUID().uuidString.prefix(8))",
+            "timestamp": ISO8601DateFormatter().string(from: Date()),
+            "packageName": bundleId, "appId": bundleId, "windowId": 0, "orientation": "portrait",
+            "screenStateId": "ios:\(th.prefix(4))", "compact": true, "nodes": nodes, "treeHash": th,
+        ]
+    }
+}

package/resources/ios/MobileSemantic/gen_project.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+# Generate MobileSemantic.xcodeproj (fixture app + UI-test bundle) via the xcodeproj gem — no Xcode
+# GUI, no xcodegen. Simulator build, no signing. Run: `ruby gen_project.rb`.
+require 'xcodeproj'
+
+here = File.dirname(File.expand_path(__FILE__))
+proj_path = File.join(here, 'MobileSemantic.xcodeproj')
+proj = Xcodeproj::Project.new(proj_path)
+
+DEPLOY = '14.0'
+# Physical-device signing (M5). Simulator builds ignore this; device builds use automatic signing
+# with this development team. Override with MSM_DEV_TEAM to use a different Apple account.
+DEV_TEAM = ENV['MSM_DEV_TEAM'] || 'A2KNU2X4F7'
+
+# --- fixture app target ------------------------------------------------------
+app = proj.new_target(:application, 'MobileSemanticFixture', :ios, DEPLOY)
+app_group = proj.new_group('Fixture', 'Fixture')
+Dir.glob(File.join(here, 'Fixture', '*.swift')).sort.each do |f|
+  ref = app_group.new_file(f)
+  app.source_build_phase.add_file_reference(ref)
+end
+
+# --- UI-test bundle target ---------------------------------------------------
+uitest = proj.new_target(:ui_test_bundle, 'MobileSemanticUITests', :ios, DEPLOY)
+ui_group = proj.new_group('UITests', 'UITests')
+Dir.glob(File.join(here, 'UITests', '*.swift')).sort.each do |f|
+  ref = ui_group.new_file(f)
+  uitest.source_build_phase.add_file_reference(ref)
+end
+uitest.add_dependency(app)
+
+# --- build settings ----------------------------------------------------------
+common = {
+  'IPHONEOS_DEPLOYMENT_TARGET' => DEPLOY,
+  'SWIFT_VERSION' => '5.0',
+  # Automatic signing so a device build works; the simulator SDK skips signing regardless.
+  'CODE_SIGN_STYLE' => 'Automatic',
+  'DEVELOPMENT_TEAM' => DEV_TEAM,
+  'CODE_SIGN_IDENTITY[sdk=iphoneos*]' => 'Apple Development',
+  'CODE_SIGNING_ALLOWED[sdk=iphonesimulator*]' => 'NO',
+  'GENERATE_INFOPLIST_FILE' => 'YES',
+  'CURRENT_PROJECT_VERSION' => '1',
+  'MARKETING_VERSION' => '1.0',
+  'ALWAYS_SEARCH_USER_PATHS' => 'NO',
+}
+app.build_configurations.each do |c|
+  c.build_settings.merge!(common)
+  c.build_settings['PRODUCT_BUNDLE_IDENTIFIER'] = 'com.msm.MobileSemanticFixture'
+  c.build_settings['INFOPLIST_KEY_UILaunchScreen_Generation'] = 'YES'
+  c.build_settings['INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents'] = 'YES'
+end
+uitest.build_configurations.each do |c|
+  c.build_settings.merge!(common)
+  c.build_settings['PRODUCT_BUNDLE_IDENTIFIER'] = 'com.msm.MobileSemanticUITests'
+  c.build_settings['TEST_TARGET_NAME'] = 'MobileSemanticFixture'
+end
+
+# --- shared scheme so `xcodebuild -scheme MobileSemanticUITests test` works ---
+proj.save
+
+scheme = Xcodeproj::XCScheme.new
+scheme.add_build_target(uitest)
+scheme.add_test_target(uitest)
+scheme.set_launch_target(app)
+scheme.save_as(proj_path, 'MobileSemanticUITests', true)
+
+puts "generated #{proj_path}"