@tapflowio/ios-agent 0.27.1 → 0.28.0

package/xctest-runner/TreeRunner/TreeServer.swift

@@ -7,13 +7,15 @@ import XCTest
 // (no Simulator.app window required — the tapflow headless path).
 //
 // Routes:
-//   GET /health                     → "ok" (readiness probe)
+//   GET /health                     → the token the host passed, or "ok" without one (readiness probe)
 //   GET /tree?bundleId=<id>         → the app's XCUIApplication.debugDescription (text)
 final class TreeServer {
     private let listener: NWListener
     private let queue = DispatchQueue(label: "dev.tapflow.treeserver")
+    private let token: String
 
-    init(port: UInt16) throws {
+    init(port: UInt16, token: String) throws {
+        self.token = token
         let params = NWParameters.tcp
         params.allowLocalEndpointReuse = true
         guard let nwPort = NWEndpoint.Port(rawValue: port) else {
@@ -33,13 +35,23 @@ final class TreeServer {
             conn.start(queue: self.queue)
             self.receive(conn, buffer: Data())
         }
-        // Surface a bind failure (e.g. port held by a stale runner) immediately by
+        // Surface a bind failure immediately by
         // exiting — otherwise the process stays alive looking "ready" and the host
         // only fails after the full 90s /health poll.
-        listener.stateUpdateHandler = { state in
-            if case .failed(let error) = state {
+        listener.stateUpdateHandler = { [weak self] state in
+            switch state {
+            case .ready:
+                // Announced only once bound, with the port the kernel gave (the host passes 0), because the host
+                // talks to nothing but the port this line names. Printed before the bind, as it once was, a runner
+                // that lost its port still announced it, and the host then read another simulator's tree from
+                // whoever held it.
+                print("TAPFLOW_TREE_READY port=\(self?.listener.port?.rawValue ?? 0)")
+                fflush(stdout)
+            case .failed(let error):
                 FileHandle.standardError.write(Data("tree server failed to bind: \(error)\n".utf8))
                 exit(1)
+            default:
+                break
             }
         }
         listener.start(queue: queue)
@@ -66,14 +78,15 @@ final class TreeServer {
         let path = parts.count >= 2 ? String(parts[1]) : "/"
         // XCUITest snapshot access must run on the main thread.
         DispatchQueue.main.async {
-            let (status, body) = Self.route(path)
+            let (status, body) = Self.route(path, token: self.token)
             self.respond(conn, status: status, body: body)
         }
     }
 
-    private static func route(_ path: String) -> (String, String) {
+    private static func route(_ path: String, token: String) -> (String, String) {
         if path.hasPrefix("/health") {
-            return ("200 OK", "ok")
+            // The token tells the host this is the runner it started, not one another agent left on the port.
+            return ("200 OK", token.isEmpty ? "ok" : token)
         }
         if path.hasPrefix("/tree") {
             guard let bundleId = query(path, "bundleId"), !bundleId.isEmpty else {

package/xctest-runner/TreeRunner/TreeServerTest.swift

@@ -2,18 +2,21 @@ import XCTest
 
 // Resident runner: starts the HTTP tree server, then blocks so the process stays
 // alive serving queries until the host terminates it (session end / shutdown).
-// The host detects readiness by polling GET /health on the chosen port.
+// The host learns the port from the TAPFLOW_TREE_READY line and confirms it with GET /health.
 final class TreeServerTest: XCTestCase {
     func testServeTree() throws {
-        let portStr = ProcessInfo.processInfo.environment["TAPFLOW_TREE_PORT"] ?? "22087"
+        // The host passes these as TEST_RUNNER_TAPFLOW_TREE_*: xcodebuild strips the prefix on the way in. Port 0
+        // lets the kernel pick, and the server announces what it got.
+        let env = ProcessInfo.processInfo.environment
+        let portStr = env["TAPFLOW_TREE_PORT"] ?? "22087"
         guard let port = UInt16(portStr) else {
             XCTFail("invalid TAPFLOW_TREE_PORT: \(portStr)")
             return
         }
-        let server = try TreeServer(port: port)
+        let server = try TreeServer(port: port, token: env["TAPFLOW_TREE_TOKEN"] ?? "")
         server.start()
-        print("TAPFLOW_TREE_READY port=\(port)")
-        // Block forever — the host kills the process to stop the runner.
-        RunLoop.current.run()
+        // Block forever — the host kills the process to stop the runner. The server's handlers hold it weakly, so
+        // keep it alive here explicitly rather than trusting the local to outlive its last use.
+        withExtendedLifetime(server) { RunLoop.current.run() }
     }
 }