@astur-mobile/ios 0.1.0-beta.0

package/assets/ios-xctest-agent/AsturAgentBridgeClient.swift

@@ -0,0 +1,144 @@
+import Foundation
+
+final class AsturAgentBridgeClient {
+    private let agent: AsturAgent
+    private let bridgeUrl: URL
+
+    /// Long-poll timeout: the agent holds the GET /command request open for up to
+    /// this duration on the server side, eliminating the 100ms polling gap.
+    /// Falls back to a short retry on network errors so the loop stays resilient.
+    private let longPollTimeout: TimeInterval = 30
+
+    init(agent: AsturAgent, bridgeUrl: URL) {
+        self.agent = agent
+        self.bridgeUrl = bridgeUrl
+    }
+
+    func run() {
+        register()
+
+        while true {
+            autoreleasepool {
+                if let command = fetchCommand() {
+                    postResult(agent.dispatch(command))
+                }
+                // No sleep — fetchCommand blocks via long-poll or returns immediately
+                // on error. A tiny back-off only on consecutive transport failures.
+            }
+        }
+    }
+
+    private func register() {
+        let info = agent.dispatch(AsturCommand(id: "register", method: "agent.ping", params: [:])).result ?? [:]
+        _ = request(
+            path: "/register",
+            method: "POST",
+            body: [
+                "id": "register",
+                "ok": true,
+                "result": info,
+                "data": info
+            ],
+            timeout: 5
+        )
+    }
+
+    private func fetchCommand() -> AsturCommand? {
+        // Long-poll: server holds the connection open until a command is queued
+        // or the timeout elapses (returns 204). This removes the old 100ms
+        // polling gap and delivers commands with near-zero latency.
+        let response = request(path: "/command", method: "GET", timeout: longPollTimeout + 2)
+        guard response.status == 200, let data = response.data else {
+            // On 204 (no command yet) or transient error, return nil and
+            // immediately re-enter the loop — no Thread.sleep needed.
+            return nil
+        }
+
+        guard
+            let raw = try? JSONSerialization.jsonObject(with: data),
+            let json = raw as? [String: Any]
+        else {
+            return nil
+        }
+
+        let id = (json["id"] as? String)?.nonEmpty ?? "unknown"
+        let method = (json["method"] as? String)?.nonEmpty
+            ?? (json["command"] as? String)?.nonEmpty
+            ?? "unknown"
+        let params = (json["params"] as? [String: Any])
+            ?? (json["payload"] as? [String: Any])
+            ?? [:]
+
+        return AsturCommand(id: id, method: method, params: params)
+    }
+
+    private func postResult(_ result: AsturCommandResult) {
+        _ = request(path: "/response", method: "POST", body: resultJson(result), timeout: 5)
+    }
+
+    private func resultJson(_ result: AsturCommandResult) -> [String: Any] {
+        var body: [String: Any] = [
+            "id": result.id,
+            "ok": result.ok,
+            "timing": [
+                "totalMs": 0,
+                "agentMs": 0,
+                "hostRoundTrips": 1,
+                "usedSnapshot": false,
+                "usedLegacyFallback": false
+            ]
+        ]
+
+        if result.ok {
+            body["result"] = result.result ?? NSNull()
+            body["data"] = result.result ?? NSNull()
+        } else {
+            var error: [String: Any] = [
+                "code": result.error?.code ?? "UNKNOWN",
+                "message": result.error?.message ?? "Unknown iOS agent error."
+            ]
+            if let details = result.error?.details {
+                error["details"] = details
+                if let detailMap = details as? [String: Any] {
+                    if let diagnostics = detailMap["diagnostics"] {
+                        body["diagnostics"] = diagnostics
+                    }
+                }
+            }
+            body["error"] = error
+        }
+
+        return body
+    }
+
+    private func request(path: String, method: String, body: [String: Any]? = nil, timeout: TimeInterval = 5) -> (status: Int, data: Data?) {
+        let url = bridgeUrl.appendingPathComponent(path.trimmingCharacters(in: CharacterSet(charactersIn: "/")))
+        var request = URLRequest(url: url)
+        request.httpMethod = method
+        request.timeoutInterval = timeout
+
+        if let body {
+            request.setValue("application/json", forHTTPHeaderField: "content-type")
+            request.httpBody = try? JSONSerialization.data(withJSONObject: body)
+        }
+
+        let semaphore = DispatchSemaphore(value: 0)
+        var status = 0
+        var data: Data?
+
+        URLSession.shared.dataTask(with: request) { responseData, response, _ in
+            status = (response as? HTTPURLResponse)?.statusCode ?? 0
+            data = responseData
+            semaphore.signal()
+        }.resume()
+
+        _ = semaphore.wait(timeout: .now() + timeout + 1)
+        return (status, data)
+    }
+}
+
+private extension String {
+    var nonEmpty: String? {
+        isEmpty ? nil : self
+    }
+}

package/assets/ios-xctest-agent/AsturAgentServer.swift

@@ -0,0 +1,249 @@
+import Foundation
+import Network
+
+final class AsturAgentServer {
+    private let port: UInt16
+    private let agent: AsturAgent
+    private let queue = DispatchQueue(label: "dev.astur.ios-agent.server")
+    private var listener: NWListener?
+
+    init(port: UInt16, agent: AsturAgent) {
+        self.port = port
+        self.agent = agent
+    }
+
+    func start() throws {
+        let listener = try NWListener(using: .tcp, on: NWEndpoint.Port(rawValue: port)!)
+        listener.stateUpdateHandler = { state in
+            print("Astur iOS agent listener state: \(state)")
+        }
+        listener.newConnectionHandler = { [weak self] connection in
+            self?.handle(connection)
+        }
+        listener.start(queue: queue)
+        self.listener = listener
+    }
+
+    func stop() {
+        listener?.cancel()
+        listener = nil
+    }
+
+    private func handle(_ connection: NWConnection) {
+        connection.start(queue: queue)
+        read(connection, buffer: Data())
+    }
+
+    private func read(_ connection: NWConnection, buffer: Data) {
+        connection.receive(minimumIncompleteLength: 1, maximumLength: 64 * 1024) { [weak self] data, _, isComplete, error in
+            guard let self else {
+                connection.cancel()
+                return
+            }
+
+            if error != nil {
+                connection.cancel()
+                return
+            }
+
+            var next = buffer
+            if let data {
+                next.append(data)
+            }
+
+            if let request = HttpRequest(data: next) {
+                self.respond(to: request, connection: connection)
+                return
+            }
+
+            if isComplete {
+                self.write(
+                    connection,
+                    status: 400,
+                    body: self.errorJson(id: "unknown", code: "BAD_REQUEST", message: "Incomplete Astur HTTP command.")
+                )
+                return
+            }
+
+            self.read(connection, buffer: next)
+        }
+    }
+
+    private func respond(to request: HttpRequest, connection: NWConnection) {
+        do {
+            let body: [String: Any]
+            if request.method == "GET" && request.path == "/health" {
+                let startedAt = Date()
+                body = resultJson(
+                    agent.dispatch(AsturCommand(id: "health", method: "agent.ping", params: [:])),
+                    elapsedMs: elapsedMs(startedAt)
+                )
+            } else if request.method == "POST" {
+                let command = try parseCommand(request.body)
+                let startedAt = Date()
+                body = resultJson(agent.dispatch(command), elapsedMs: elapsedMs(startedAt))
+            } else {
+                body = errorJson(
+                    id: "unknown",
+                    code: "UNSUPPORTED_HTTP_METHOD",
+                    message: "Astur agent expects POST commands."
+                )
+            }
+
+            write(connection, status: 200, body: body)
+        } catch {
+            write(
+                connection,
+                status: 500,
+                body: errorJson(
+                    id: "unknown",
+                    code: "SERVER_ERROR",
+                    message: String(describing: error)
+                )
+            )
+        }
+    }
+
+    private func parseCommand(_ body: Data) throws -> AsturCommand {
+        let raw = try JSONSerialization.jsonObject(with: body)
+        guard let json = raw as? [String: Any] else {
+            throw ServerFailure("Astur command must be a JSON object.")
+        }
+
+        let id = (json["id"] as? String)?.nonEmpty ?? "unknown"
+        let method = (json["method"] as? String)?.nonEmpty
+            ?? (json["command"] as? String)?.nonEmpty
+
+        guard let method else {
+            throw ServerFailure("Astur command must include method or command.")
+        }
+
+        let params = (json["params"] as? [String: Any])
+            ?? (json["payload"] as? [String: Any])
+            ?? [:]
+
+        return AsturCommand(id: id, method: method, params: params)
+    }
+
+    private func resultJson(_ result: AsturCommandResult, elapsedMs: Int) -> [String: Any] {
+        var body: [String: Any] = [
+            "id": result.id,
+            "ok": result.ok,
+            "timing": [
+                "totalMs": elapsedMs,
+                "agentMs": elapsedMs,
+                "hostRoundTrips": 1,
+                "usedSnapshot": false,
+                "usedLegacyFallback": false
+            ]
+        ]
+
+        if result.ok {
+            body["result"] = result.result ?? NSNull()
+            body["data"] = result.result ?? NSNull()
+        } else {
+            var error: [String: Any] = [
+                "code": result.error?.code ?? "UNKNOWN",
+                "message": result.error?.message ?? "Unknown iOS agent error."
+            ]
+            if let details = result.error?.details {
+                error["details"] = details
+                if let detailMap = details as? [String: Any] {
+                    body["diagnostics"] = detailMap["diagnostics"] ?? detailMap
+                }
+            }
+            body["error"] = error
+        }
+
+        return body
+    }
+
+    private func errorJson(id: String, code: String, message: String) -> [String: Any] {
+        [
+            "id": id,
+            "ok": false,
+            "error": [
+                "code": code,
+                "message": message
+            ],
+            "timing": [
+                "totalMs": 0,
+                "agentMs": 0,
+                "hostRoundTrips": 1
+            ]
+        ]
+    }
+
+    private func write(_ connection: NWConnection, status: Int, body: [String: Any]) {
+        let payload = (try? JSONSerialization.data(withJSONObject: body)) ?? Data()
+        var response = Data()
+        let header = """
+        HTTP/1.1 \(status) \(status == 200 ? "OK" : "Error")\r
+        content-type: application/json\r
+        content-length: \(payload.count)\r
+        connection: close\r
+        \r
+
+        """
+        response.append(header.data(using: .utf8)!)
+        response.append(payload)
+        connection.send(content: response, completion: .contentProcessed { _ in
+            connection.cancel()
+        })
+    }
+
+    private func elapsedMs(_ startedAt: Date) -> Int {
+        max(0, Int(Date().timeIntervalSince(startedAt) * 1_000))
+    }
+}
+
+private struct HttpRequest {
+    let method: String
+    let path: String
+    let body: Data
+
+    init?(data: Data) {
+        guard let separator = data.range(of: Data("\r\n\r\n".utf8)) else {
+            return nil
+        }
+
+        let headerData = data[..<separator.lowerBound]
+        guard let header = String(data: headerData, encoding: .utf8) else {
+            return nil
+        }
+
+        let lines = header.components(separatedBy: "\r\n")
+        let requestLine = lines.first?.split(separator: " ").map(String.init) ?? []
+        guard requestLine.count >= 2 else {
+            return nil
+        }
+
+        let contentLength = lines
+            .first { $0.lowercased().hasPrefix("content-length:") }
+            .flatMap { Int($0.split(separator: ":", maxSplits: 1).last?.trimmingCharacters(in: .whitespaces) ?? "") }
+            ?? 0
+
+        let bodyStart = separator.upperBound
+        guard data.count - bodyStart >= contentLength else {
+            return nil
+        }
+
+        self.method = requestLine[0]
+        self.path = requestLine[1]
+        self.body = data[bodyStart..<(bodyStart + contentLength)]
+    }
+}
+
+private struct ServerFailure: Error, CustomStringConvertible {
+    let description: String
+
+    init(_ description: String) {
+        self.description = description
+    }
+}
+
+private extension String {
+    var nonEmpty: String? {
+        isEmpty ? nil : self
+    }
+}

package/assets/ios-xctest-agent/AsturAgentUITests-Info.plist

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>ASTUR_AUT_BUNDLE_ID</key>
+	<string>$(ASTUR_AUT_BUNDLE_ID)</string>
+	<key>ASTUR_AUT_LAUNCH</key>
+	<string>$(ASTUR_AUT_LAUNCH)</string>
+	<key>ASTUR_IOS_AGENT_BRIDGE_URL</key>
+	<string>$(ASTUR_IOS_AGENT_BRIDGE_URL)</string>
+	<key>ASTUR_IOS_AGENT_PORT</key>
+	<string>$(ASTUR_IOS_AGENT_PORT)</string>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+</dict>
+</plist>

package/assets/ios-xctest-agent/AsturAgentUITests.swift

@@ -0,0 +1,55 @@
+import XCTest
+
+final class AsturAgentUITests: XCTestCase {
+    private var server: AsturAgentServer?
+
+    override func tearDown() {
+        server?.stop()
+        server = nil
+        super.tearDown()
+    }
+
+    func testAgentServer() throws {
+        let environment = ProcessInfo.processInfo.environment
+        let bundleIdentifier = runtimeValue("ASTUR_AUT_BUNDLE_ID", environment: environment) ?? "com.astur.demo"
+        let port = UInt16(runtimeValue("ASTUR_IOS_AGENT_PORT", environment: environment) ?? "8788") ?? 8788
+        let shouldLaunch = runtimeValue("ASTUR_AUT_LAUNCH", environment: environment) != "0"
+        let bridgeUrl = runtimeValue("ASTUR_IOS_AGENT_BRIDGE_URL", environment: environment).flatMap(URL.init(string:))
+
+        let agent = AsturAgent(bundleIdentifier: bundleIdentifier)
+        if shouldLaunch {
+            agent.launchIfNeeded()
+        }
+
+        if let bridgeUrl {
+            AsturAgentBridgeClient(agent: agent, bridgeUrl: bridgeUrl).run()
+            return
+        }
+
+        let server = AsturAgentServer(port: port, agent: agent)
+        try server.start()
+        self.server = server
+
+        RunLoop.current.run()
+    }
+
+    private func runtimeValue(_ key: String, environment: [String: String]) -> String? {
+        if let value = environment[key]?.nonEmpty, !value.hasPrefix("$(") {
+            return value
+        }
+
+        if let value = Bundle(for: AsturAgentUITests.self).object(forInfoDictionaryKey: key) as? String,
+           let nonEmpty = value.nonEmpty,
+           !nonEmpty.hasPrefix("$(") {
+            return nonEmpty
+        }
+
+        return nil
+    }
+}
+
+private extension String {
+    var nonEmpty: String? {
+        isEmpty ? nil : self
+    }
+}