agent-device 0.21.23 → 0.21.25

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+TextTyping.swift

@@ -34,7 +34,7 @@ extension RunnerTests {
             failure: .notFocused
           )
         }
-        clearTextInput(clearTarget)
+        clearTextInput(app: app, clearTarget)
 
 
         let observed = editableTextValue(for: clearTarget, treatingPlaceholderAsEmpty: true)
@@ -125,7 +125,7 @@ extension RunnerTests {
       }
       if currentText == nil || currentText?.isEmpty == false {
         let clearStartedAt = Date()
-        clearTextInput(replacementTarget)
+        clearTextInput(app: app, replacementTarget)
         activeTarget = activeTarget.withElement(replacementTarget)
         logTextEntryPhase(
           commandId: commandId,
@@ -342,13 +342,12 @@ extension RunnerTests {
       )
     }
     let verifyStartedAt = Date()
-    var result = verifyTextEntryWithRepairIfNeeded(
-      app: app,
-      target: activeTarget,
-      expectedText: expectedText,
-      repairMode: repairMode,
-      baseline: entryBaseline
-    )
+    var result: TextEntryResult
+    if repairMode == .replacement {
+      result = observeReplacementTextEntry(app: app, target: activeTarget, requested: text, baseline: entryBaseline)
+    } else {
+      result = verifyAppendTextEntryWithRepairIfNeeded(app: app, target: activeTarget, expectedText: expectedText)
+    }
     logTextEntryPhase(
       commandId: commandId,
       phase: "verify",
@@ -389,12 +388,39 @@ extension RunnerTests {
     }
   }
 
-  private func verifyTextEntryWithRepairIfNeeded(
+  private func observeReplacementTextEntry(
     app: XCUIApplication,
     target: TextEntryTarget,
-    expectedText: String?,
-    repairMode: TextTypingRepairMode,
+    requested: String,
     baseline: TextEntryObservation?
+  ) -> TextEntryResult {
+    var confirmation = ReplacementTextEntryConfirmation(requested: requested, baseline: baseline, startedAt: Date())
+    while true {
+      guard let element = resolveTextEntryElement(app: app, target: target) else {
+        let failure: TextEntryFailure? = target.boundIdentity != nil && !boundTextEntryInputIsGone(app: app, target: target)
+          ? .commitNotObserved : nil
+        if target.boundIdentity != nil && failure == nil {
+          NSLog("AGENT_DEVICE_RUNNER_TEXT_ENTRY_INPUT_REMOVED_AFTER_DELIVERY")
+        }
+        return TextEntryResult(verified: nil, repaired: false, expectedText: requested, observedText: nil, failure: failure)
+      }
+      guard let observed = textEntryObservation(for: element) else {
+        return TextEntryResult(verified: nil, repaired: false, expectedText: requested, observedText: nil)
+      }
+      if let result = confirmation.observe(observed, at: Date()) {
+        if result.unconfirmed != nil {
+          NSLog("AGENT_DEVICE_RUNNER_TEXT_ENTRY_UNCONFIRMED expectedLength=%d observedLength=%d repaired=0", requested.count, observed.value.count)
+        }
+        return result
+      }
+      sleepFor(TextEntryTiming.pollInterval)
+    }
+  }
+
+  private func verifyAppendTextEntryWithRepairIfNeeded(
+    app: XCUIApplication,
+    target: TextEntryTarget,
+    expectedText: String?
   ) -> TextEntryResult {
     if target.boundIdentity != nil, resolveTextEntryElement(app: app, target: target) == nil {
       guard boundTextEntryInputIsGone(app: app, target: target) else {
@@ -417,27 +443,16 @@ extension RunnerTests {
       expectedText: expectedText,
       repaired: false
     )
-
-
-    if let unconfirmed = settledUnconfirmedTextEntry(
-      app: app,
-      target: target,
-      result: initialResult,
-      baseline: baseline
-    ) {
-      return unconfirmed
-    }
 #if os(iOS)
     guard initialResult.verified == false,
           let expectedText = initialResult.expectedText
     else {
       return initialResult
     }
-    guard shouldRepairTextEntry(
+    guard shouldRepairAppendTextEntry(
       app: app,
       target: target,
-      expectedText: expectedText,
-      repairMode: repairMode
+      expectedText: expectedText
     ) else {
       return verifyTextEntry(
         app: app,
@@ -465,7 +480,7 @@ extension RunnerTests {
       expectedText.count,
       observedText.count
     )
-    clearTextInput(repairTarget)
+    clearTextInput(app: app, repairTarget)
     repairTarget.typeText(expectedText)
     let repairedTarget = target.withElement(repairTarget)
     let repairedResult = verifyTextEntry(
@@ -474,76 +489,12 @@ extension RunnerTests {
       expectedText: expectedText,
       repaired: true
     )
-    return settledUnconfirmedTextEntry(
-      app: app,
-      target: repairedTarget,
-      result: repairedResult,
-      baseline: baseline
-    ) ?? repairedResult
+    return repairedResult
 #else
     return initialResult
 #endif
   }
 
-
-
-  private func settledUnconfirmedTextEntry(
-    app: XCUIApplication,
-    target: TextEntryTarget,
-    result: TextEntryResult,
-    baseline: TextEntryObservation?
-  ) -> TextEntryResult? {
-    guard result.verified == false, let requested = result.expectedText, let baseline else {
-      return nil
-    }
-    func observe() -> TextEntryObservation? {
-      textEntryObservation(for: resolveTextEntryElement(app: app, target: target))
-    }
-    func evidence(_ observed: TextEntryObservation?) -> TextEntryUnconfirmedEvidence? {
-      Self.unconfirmedTextEntryEvidence(requested: requested, baseline: baseline, observed: observed)
-    }
-    let moveDeadline = Date().addingTimeInterval(TextEntryTiming.unconfirmedSettleCeiling)
-    var latest = observe()
-    while let unmoved = latest, unmoved.isSettled(with: baseline), Date() < moveDeadline {
-      sleepFor(TextEntryTiming.pollInterval)
-      latest = observe()
-    }
-    guard evidence(latest) != nil else {
-      return nil
-    }
-    let ceiling = Date().addingTimeInterval(TextEntryTiming.unconfirmedSettleCeiling)
-    var stableSince = Date()
-    while Date().timeIntervalSince(stableSince) < TextEntryTiming.verificationStabilityWindow {
-      guard Date() < ceiling else {
-        return nil
-      }
-      sleepFor(TextEntryTiming.pollInterval)
-      let next = observe()
-      if let next, let settled = latest, next.isSettled(with: settled) {
-        latest = next
-        continue
-      }
-      latest = next
-      stableSince = Date()
-    }
-    guard let unconfirmed = evidence(latest) else {
-      return nil
-    }
-    NSLog(
-      "AGENT_DEVICE_RUNNER_TEXT_ENTRY_UNCONFIRMED expectedLength=%d observedLength=%d repaired=%d",
-      requested.count,
-      unconfirmed.after.count,
-      result.repaired ? 1 : 0
-    )
-    return TextEntryResult(
-      verified: nil,
-      repaired: result.repaired,
-      expectedText: requested,
-      observedText: unconfirmed.after,
-      unconfirmed: unconfirmed
-    )
-  }
-
   private func verifyTextEntry(
     app: XCUIApplication,
     target: TextEntryTarget,
@@ -631,11 +582,10 @@ extension RunnerTests {
     }
   }
 
-  private func shouldRepairTextEntry(
+  private func shouldRepairAppendTextEntry(
     app: XCUIApplication,
     target: TextEntryTarget,
-    expectedText: String,
-    repairMode: TextTypingRepairMode
+    expectedText: String
   ) -> Bool {
 #if os(iOS)
     var latestObservedText: String?
@@ -652,10 +602,9 @@ extension RunnerTests {
         return false
       }
       latestObservedText = observedText
-      if !isRepairableTextEntryMismatch(
+      if !isRepairableAppendTextEntryMismatch(
         observedText: observedText,
-        expectedText: expectedText,
-        repairMode: repairMode
+        expectedText: expectedText
       ) {
         return false
       }
@@ -672,27 +621,22 @@ extension RunnerTests {
     ) else {
       return false
     }
-    return isRepairableTextEntryMismatch(
+    return isRepairableAppendTextEntryMismatch(
       observedText: latestObservedText,
-      expectedText: expectedText,
-      repairMode: repairMode
+      expectedText: expectedText
     )
 #else
     return false
 #endif
   }
 
-  private func isRepairableTextEntryMismatch(
+  private func isRepairableAppendTextEntryMismatch(
     observedText: String,
-    expectedText: String,
-    repairMode: TextTypingRepairMode
+    expectedText: String
   ) -> Bool {
     guard observedText != expectedText else {
       return false
     }
-    if repairMode == .replacement {
-      return true
-    }
     return observedText.isEmpty || isLikelyDroppedCharacterTextEntryMismatch(
       observedText: observedText,
       expectedText: expectedText

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Transport.swift

@@ -4,43 +4,119 @@ import Network
 extension RunnerTests {
 
 
+
+
+  static let requestTimeout: TimeInterval = 30
+
+
+
   func handle(connection: NWConnection) {
-    receiveRequest(connection: connection, buffer: Data())
+    guard let token = listenerToken else {
+      connection.cancel()
+      return
+    }
+    connection.stateUpdateHandler = { [weak self] state in
+      switch state {
+      case .ready:
+        connection.stateUpdateHandler = nil
+        self?.admit(connection, token: token)
+      case .failed:
+        connection.cancel()
+      default:
+        break
+      }
+    }
+    connection.start(queue: transportQueue)
+  }
+
+  private func admit(_ connection: NWConnection, token: RunnerListenerToken) {
+    let peer = RunnerListenerPeer.of(connection)
+    guard peer != .directNetwork else {
+      connection.cancel()
+      return
+    }
+    let inbound = RunnerInboundRequest(token: token)
+    if peer == .tunnel {
+      armDeadline(for: inbound, over: connection)
+    }
+    receiveRequest(inbound, over: connection)
   }
 
 
 
-  private func receiveRequest(connection: NWConnection, buffer: Data) {
-    connection.receive(minimumIncompleteLength: 1, maximumLength: 1024 * 1024) { [weak self] data, _, _, _ in
-      guard let self = self, let data = data else {
+  private func receiveRequest(_ inbound: RunnerInboundRequest, over connection: NWConnection) {
+    connection.receive(minimumIncompleteLength: 1, maximumLength: 64 * 1024) {
+      [weak self] data, _, isComplete, error in
+      guard let self, !inbound.closed else { return }
+      if let data, !data.isEmpty {
+        self.consume(data, for: inbound, over: connection)
+      } else if error != nil || isComplete {
+        inbound.close()
         connection.cancel()
-        return
+      } else {
+        self.receiveRequest(inbound, over: connection)
       }
-      if buffer.count + data.count > self.maxRequestBytes {
-        let response = self.jsonResponse(
-          status: 413,
-          response: self.errorResponse(
-            code: "INVALID_ARGS",
-            message: "runner request body exceeds \(self.maxRequestBytes) bytes",
-            hint: "Send one runner command per request and keep the payload below the runner request limit."
-          )
-        )
-        self.sendResponse(response, over: connection) { [weak self] in
-          self?.finish()
-        }
+    }
+  }
+
+  private func consume(_ data: Data, for inbound: RunnerInboundRequest, over connection: NWConnection) {
+    if inbound.deadline == nil {
+      armDeadline(for: inbound, over: connection)
+    }
+    let alreadyScanned = inbound.buffer.count
+    inbound.buffer.append(data)
+    if inbound.head == nil {
+      switch RunnerHttpRequestFraming.admitHead(
+        inbound.buffer,
+        token: inbound.token,
+        alreadyScanned: alreadyScanned
+      ) {
+      case .incomplete:
+        receiveRequest(inbound, over: connection)
         return
+      case .rejected(let rejection):
+        reject(inbound, with: rejection, over: connection)
+        return
+      case .admitted(let head):
+        inbound.head = head
       }
-      let combined = buffer + data
-      if let body = self.parseRequest(data: combined) {
-        self.handleRequestBody(body) { [weak self] result in
-          self?.sendResult(result, over: connection)
-        }
-      } else {
-        self.receiveRequest(connection: connection, buffer: combined)
-      }
+    }
+    guard let head = inbound.head else { return }
+    let bodyEnd = head.bodyOffset + head.contentLength
+    guard inbound.buffer.count >= bodyEnd else {
+      receiveRequest(inbound, over: connection)
+      return
+    }
+    inbound.close()
+    let body = inbound.buffer.subdata(in: head.bodyOffset..<bodyEnd)
+    handleRequestBody(body) { [weak self] result in
+      self?.sendResult(result, over: connection)
     }
   }
 
+  private func armDeadline(for inbound: RunnerInboundRequest, over connection: NWConnection) {
+    let deadline = DispatchWorkItem { [weak self, inbound] in
+      guard let self, !inbound.closed else { return }
+      self.reject(inbound, with: .timedOut, over: connection)
+    }
+    inbound.deadline = deadline
+    transportQueue.asyncAfter(deadline: .now() + Self.requestTimeout, execute: deadline)
+  }
+
+  private func reject(
+    _ inbound: RunnerInboundRequest,
+    with rejection: RunnerHttpRequestRejection,
+    over connection: NWConnection
+  ) {
+    inbound.close()
+    NSLog("AGENT_DEVICE_RUNNER_REQUEST_REJECTED status=%d", rejection.status)
+    let response = jsonResponse(
+      status: rejection.status,
+      response: errorResponse(code: rejection.code, message: rejection.message)
+    )
+    sendResponse(response, over: connection)
+  }
+
   private func sendResult(
     _ result: (data: Data, shouldFinish: Bool),
     over connection: NWConnection
@@ -66,34 +142,6 @@ extension RunnerTests {
     })
   }
 
-  private func parseRequest(data: Data) -> Data? {
-    guard let headerEnd = data.range(of: Data("\r\n\r\n".utf8)) else {
-      return nil
-    }
-    let headerData = data.subdata(in: 0..<headerEnd.lowerBound)
-    let bodyStart = headerEnd.upperBound
-    let headers = String(decoding: headerData, as: UTF8.self)
-    let contentLength = extractContentLength(headers: headers)
-    guard let contentLength = contentLength else {
-      return nil
-    }
-    if data.count < bodyStart + contentLength {
-      return nil
-    }
-    let body = data.subdata(in: bodyStart..<(bodyStart + contentLength))
-    return body
-  }
-
-  private func extractContentLength(headers: String) -> Int? {
-    for line in headers.split(separator: "\r\n") {
-      let parts = line.split(separator: ":", maxSplits: 1).map { $0.trimmingCharacters(in: .whitespaces) }
-      if parts.count == 2 && parts[0].lowercased() == "content-length" {
-        return Int(parts[1])
-      }
-    }
-    return nil
-  }
-
   private func handleRequestBody(
     _ body: Data,
     completion: @escaping @Sendable ((data: Data, shouldFinish: Bool)) -> Void
@@ -297,9 +345,10 @@ extension RunnerTests {
 
   private func httpResponse(status: Int, body: String) -> Data {
     let headers = [
-      "HTTP/1.1 \(status) OK",
+      "HTTP/1.1 \(status) \(Self.reasonPhrase(status))",
       "Content-Type: application/json",
       "Content-Length: \(body.utf8.count)",
+      "\(Self.authEnforcedResponseHeader): required",
       "Connection: close",
       "",
       body
@@ -307,6 +356,24 @@ extension RunnerTests {
     return Data(headers.utf8)
   }
 
+
+  static let authEnforcedResponseHeader = "X-Agent-Device-Runner-Auth"
+
+  private static func reasonPhrase(_ status: Int) -> String {
+    switch status {
+    case 200: return "OK"
+    case 400: return "Bad Request"
+    case 401: return "Unauthorized"
+    case 404: return "Not Found"
+    case 405: return "Method Not Allowed"
+    case 408: return "Request Timeout"
+    case 411: return "Length Required"
+    case 413: return "Content Too Large"
+    case 431: return "Request Header Fields Too Large"
+    default: return "Internal Server Error"
+    }
+  }
+
   private func finish() {
     listener?.cancel()
     listener = nil
@@ -316,3 +383,24 @@ extension RunnerTests {
     doneExpectation = nil
   }
 }
+
+
+final class RunnerInboundRequest {
+  let token: RunnerListenerToken
+  var buffer = Data()
+  var head: RunnerHttpAdmittedHead?
+  var deadline: DispatchWorkItem?
+  private(set) var closed = false
+
+  init(token: RunnerListenerToken) {
+    self.token = token
+  }
+
+
+
+  func close() {
+    closed = true
+    deadline?.cancel()
+    deadline = nil
+  }
+}

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+TypeExecution.swift

@@ -108,7 +108,10 @@ extension RunnerTests {
         ok: false,
         error: ErrorPayload(
           code: "TEXT_ENTRY_MISMATCH",
-          message: "text entry verification failed: expected \"\(expected)\", observed \"\(observed)\""
+          message: "text entry read-back did not match: expected \"\(expected)\", observed \"\(observed)\"",
+          hint: textEntryMode == .replacement
+            ? "The app may have formatted, filtered, or consumed the entry. Inspect the field or resulting screen before retrying. If it needs correction, retry fill with the full text and --delay-ms \(TextEntryTiming.recoveryDelayMilliseconds)."
+            : nil
         )
       )
     }

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests.swift

@@ -50,6 +50,7 @@ final class RunnerTests: XCTestCase {
   }()
   static let defaultRecordingFps: Int32 = 15
   var listener: NWListener?
+  var listenerToken: RunnerListenerToken?
   var doneExpectation: XCTestExpectation?
   let transportQueue = DispatchQueue(label: "agent-device.runner.transport")
   let commandExecutionQueue = DispatchQueue(label: "agent-device.runner.commands")
@@ -64,7 +65,6 @@ final class RunnerTests: XCTestCase {
 
 
   var textEntryTapWitness: TextEntryTapWitness?
-  let maxRequestBytes = 2 * 1024 * 1024
   static let mainThreadExecutionTimeout: TimeInterval = 30
   let appExistenceTimeout: TimeInterval = 30
   let retryCooldown: TimeInterval = 0.2
@@ -291,9 +291,15 @@ final class RunnerTests: XCTestCase {
   func testCommand() throws {
     doneExpectation = expectation(description: "agent-device command handled")
     NSLog("AGENT_DEVICE_RUNNER_HEADLESS_STARTUP=1")
-    let desiredPort = RunnerEnv.resolvePort()
-    NSLog("AGENT_DEVICE_RUNNER_DESIRED_PORT=%d", desiredPort)
-    listener = try makeRunnerListener(desiredPort: desiredPort)
+    guard let configuration = RunnerListenerConfiguration.fromEnvironment() else {
+      NSLog("AGENT_DEVICE_RUNNER_LISTENER_CONFIGURATION_MISSING")
+      XCTFail("runner listener port or token is missing; refusing to listen")
+      return
+    }
+    listenerToken = configuration.token
+    NSLog("AGENT_DEVICE_RUNNER_AUTH=required")
+    NSLog("AGENT_DEVICE_RUNNER_DESIRED_PORT=%d", configuration.port.rawValue)
+    listener = try Self.makeRunnerListener(port: configuration.port)
     listener?.stateUpdateHandler = { [weak self] state in
       switch state {
       case .ready:
@@ -311,9 +317,7 @@ final class RunnerTests: XCTestCase {
       }
     }
     listener?.newConnectionHandler = { [weak self] conn in
-      guard let self else { return }
-      conn.start(queue: self.transportQueue)
-      self.handle(connection: conn)
+      self?.handle(connection: conn)
     }
     listener?.start(queue: transportQueue)
     let idleKeepaliveTimer = DispatchSource.makeTimerSource(queue: transportQueue)
@@ -341,17 +345,15 @@ final class RunnerTests: XCTestCase {
     }
   }
 
-  private func makeRunnerListener(desiredPort: UInt16) throws -> NWListener {
-    if desiredPort > 0, let port = NWEndpoint.Port(rawValue: desiredPort) {
-      #if os(macOS)
-        let parameters = NWParameters.tcp
-        parameters.allowLocalEndpointReuse = true
-        parameters.requiredLocalEndpoint = .hostPort(host: "127.0.0.1", port: port)
-        return try NWListener(using: parameters)
-      #else
-        return try NWListener(using: .tcp, on: port)
-      #endif
-    }
-    return try NWListener(using: .tcp)
+
+
+  static func makeRunnerListener(port: NWEndpoint.Port) throws -> NWListener {
+    #if targetEnvironment(simulator) || os(macOS)
+      let parameters = NWParameters.tcp
+      parameters.requiredLocalEndpoint = .hostPort(host: .ipv4(.loopback), port: port)
+      return try NWListener(using: parameters)
+    #else
+      return try NWListener(using: .tcp, on: port)
+    #endif
   }
 }

package/dist/src/absence-observation-errors.js

@@ -0,0 +1 @@
+import{I as e,P as t}from"./sdk-contracts.js";import{o as n,s as r}from"./back-mode.js";import{t as i}from"./interaction-error.js";function a(e,n=`is`){return new t(`INVALID_ARGS`,r(e,n),{command:n,predicate:`absent`,rejectedOption:e})}function o(e,r,a=`is`){let o=`firstMatch`in r?r.firstMatch:void 0,s={command:a,reason:i.predicateFailed,predicate:`absent`,selector:e,matches:r.matches,observation:r.kind,...o?{firstMatch:o}:{},...r.kind===`sparse`?{snapshotQuality:r.quality}:{},...r.kind===`truncated`?{truncated:!0}:{}};if(r.kind===`present`){let n=r.matches>1;return new t(`COMMAND_FAILED`,`${a} absent failed for selector ${e}: ${r.matches} match${n?`es`:``} found`,{...s,...n?{hint:`Refine the selector to match no elements.`}:{}})}return new t(`COMMAND_FAILED`,`${a} absent could not prove absence for selector ${e}: ${n[r.kind]}`,{...s,hint:`Retry after the accessibility capture is complete.`})}function s(n,r,a=`is`){let o=e(r),s=typeof o.details?.reason==`string`?o.details.reason:typeof o.details?.androidSnapshotHelperFailureReason==`string`?o.details.androidSnapshotHelperFailureReason:void 0;return new t(`COMMAND_FAILED`,`${a} absent could not prove absence for selector ${n}: capture was unreadable`,{command:a,reason:i.predicateFailed,predicate:`absent`,selector:n,matches:0,observation:`unreadable`,captureErrorCode:o.code,...s?{captureErrorReason:s}:{},hint:`Retry after the accessibility capture is readable.`},o)}export{o as n,s as r,a as t};