import AppKit
|
import ApplicationServices
|
import Foundation
|
|
struct WindowState: Codable {
|
let windowID: Int64?
|
let x: Double
|
let y: Double
|
let width: Double
|
let height: Double
|
let minimized: Bool
|
let source: Bool
|
}
|
|
struct RestoreSummary {
|
let mutableRecorded: Int
|
let restored: Int
|
let mutationFailures: Int
|
|
var exitCode: Int32 {
|
restored == mutableRecorded && mutationFailures == 0 ? 0 : 75
|
}
|
}
|
|
enum AXReadFailure: Error {
|
case nonBenign(AXError)
|
case traversalLimit
|
}
|
|
enum BindingPlanFailure: Error {
|
case invalidSource
|
case duplicateNonSourceID
|
case missingNonSource
|
case readError
|
}
|
|
struct WindowBindingPlan {
|
let states: [WindowState]
|
let windowIndices: [Int]
|
}
|
|
enum IsolationFailureStage: String, Equatable {
|
case otherWindowMinimizeSetFailed = "OTHER_WINDOW_MINIMIZE_SET_FAILED"
|
case sourceUnminimizeSetFailed = "SOURCE_UNMINIMIZE_SET_FAILED"
|
case sourceSizeSetFailed = "SOURCE_SIZE_SET_FAILED"
|
case sourcePositionSetFailed = "SOURCE_POSITION_SET_FAILED"
|
case sourceRaiseFailed = "SOURCE_RAISE_FAILED"
|
case sourceReadbackAXFailed = "SOURCE_READBACK_AX_FAILED"
|
case sourceReadbackMismatch = "SOURCE_READBACK_MISMATCH"
|
}
|
|
enum PreStateFailureStage: String, Equatable {
|
case finderNotRunning = "FINDER_NOT_RUNNING"
|
case finderWindowsReadFailed = "FINDER_WINDOWS_READ_FAILED"
|
case stateEncodeFailed = "STATE_ENCODE_FAILED"
|
case stateAtomicWriteFailed = "STATE_ATOMIC_WRITE_FAILED"
|
}
|
|
enum StatePersistenceFailure: Error, Equatable {
|
case encode
|
case atomicWrite
|
|
var stage: PreStateFailureStage {
|
switch self {
|
case .encode: return .stateEncodeFailed
|
case .atomicWrite: return .stateAtomicWriteFailed
|
}
|
}
|
}
|
|
enum IsolationMutationResult: Equatable {
|
case success
|
case failure(IsolationFailureStage)
|
}
|
|
struct IsolationFailureResult {
|
let line: String
|
let exitCode: Int32
|
}
|
|
func preStateFailureLine(_ stage: PreStateFailureStage) -> String {
|
"stage=\(stage.rawValue) mutation=0"
|
}
|
|
func persistStateSnapshot(
|
encode: () throws -> Data,
|
atomicWrite: (Data) throws -> Void
|
) -> Result<Void, StatePersistenceFailure> {
|
let data: Data
|
do { data = try encode() } catch { return .failure(.encode) }
|
do { try atomicWrite(data) } catch { return .failure(.atomicWrite) }
|
return .success(())
|
}
|
|
func isBenignAbsence(_ error: AXError) -> Bool {
|
error == .noValue || error == .attributeUnsupported
|
}
|
|
func uniqueSourceWindow(_ result: Result<[Int], AXReadFailure>) throws -> Int? {
|
let perWindowMatchCounts = try result.get()
|
guard perWindowMatchCounts.reduce(0, +) == 1 else { return nil }
|
return perWindowMatchCounts.firstIndex(of: 1)
|
}
|
|
func buildIsolationPlan(
|
sourceIndex: Int,
|
windowCount: Int,
|
windowID: (Int) -> Result<Int64?, AXReadFailure>,
|
rect: (Int) -> Result<CGRect?, AXReadFailure>,
|
minimized: (Int) -> Result<Bool?, AXReadFailure>
|
) -> Result<WindowBindingPlan, BindingPlanFailure> {
|
guard (0..<windowCount).contains(sourceIndex) else { return .failure(.invalidSource) }
|
let sourceRect: CGRect
|
switch rect(sourceIndex) {
|
case .failure: return .failure(.readError)
|
case .success(let value):
|
guard let value, validRect(value) else { return .failure(.invalidSource) }
|
sourceRect = value
|
}
|
let sourceMinimized: Bool
|
switch minimized(sourceIndex) {
|
case .failure: return .failure(.readError)
|
case .success(let value):
|
guard let value else { return .failure(.invalidSource) }
|
sourceMinimized = value
|
}
|
var states = [WindowState(
|
windowID: nil,
|
x: sourceRect.origin.x,
|
y: sourceRect.origin.y,
|
width: sourceRect.width,
|
height: sourceRect.height,
|
minimized: sourceMinimized,
|
source: true
|
)]
|
var indices = [sourceIndex]
|
var usedIDs: Set<Int64> = []
|
for index in 0..<windowCount where index != sourceIndex {
|
let id: Int64
|
switch windowID(index) {
|
case .failure: return .failure(.readError)
|
case .success(nil): continue
|
case .success(let value): id = value!
|
}
|
guard usedIDs.insert(id).inserted else { return .failure(.duplicateNonSourceID) }
|
let windowRect: CGRect
|
switch rect(index) {
|
case .failure: return .failure(.readError)
|
case .success(let value):
|
guard let value, validRect(value) else { continue }
|
windowRect = value
|
}
|
let windowMinimized: Bool
|
switch minimized(index) {
|
case .failure: return .failure(.readError)
|
case .success(let value):
|
guard let value else { continue }
|
windowMinimized = value
|
}
|
states.append(WindowState(
|
windowID: id,
|
x: windowRect.origin.x,
|
y: windowRect.origin.y,
|
width: windowRect.width,
|
height: windowRect.height,
|
minimized: windowMinimized,
|
source: false
|
))
|
indices.append(index)
|
}
|
return .success(WindowBindingPlan(states: states, windowIndices: indices))
|
}
|
|
func buildRestorePlan(
|
states: [WindowState],
|
sourceIndex: Int?,
|
windowCount: Int,
|
windowID: (Int) -> Result<Int64?, AXReadFailure>,
|
sourceRect: () -> Result<CGRect?, AXReadFailure>,
|
sourceMinimized: () -> Result<Bool?, AXReadFailure>
|
) -> Result<WindowBindingPlan, BindingPlanFailure> {
|
guard let sourceIndex, (0..<windowCount).contains(sourceIndex),
|
states.filter(\.source).count == 1,
|
let sourceState = states.first(where: \.source) else { return .failure(.invalidSource) }
|
switch sourceRect() {
|
case .failure: return .failure(.readError)
|
case .success(let value): guard let value, validRect(value) else { return .failure(.invalidSource) }
|
}
|
switch sourceMinimized() {
|
case .failure: return .failure(.readError)
|
case .success(let value): guard value != nil else { return .failure(.invalidSource) }
|
}
|
var currentByID: [Int64: Int] = [:]
|
for index in 0..<windowCount where index != sourceIndex {
|
switch windowID(index) {
|
case .failure: return .failure(.readError)
|
case .success(nil): continue
|
case .success(let value):
|
let id = value!
|
guard currentByID[id] == nil else { return .failure(.duplicateNonSourceID) }
|
currentByID[id] = index
|
}
|
}
|
var stateIDs: Set<Int64> = []
|
var planStates = [sourceState]
|
var indices = [sourceIndex]
|
for state in states where !state.source {
|
guard let id = state.windowID, stateIDs.insert(id).inserted,
|
let index = currentByID[id] else { return .failure(.missingNonSource) }
|
planStates.append(state)
|
indices.append(index)
|
}
|
return .success(WindowBindingPlan(states: planStates, windowIndices: indices))
|
}
|
|
func restoreRecorded(
|
_ plan: WindowBindingPlan,
|
restore: (WindowState, Int) -> Bool
|
) -> Bool {
|
zip(plan.states, plan.windowIndices).map(restore).allSatisfy { $0 }
|
}
|
|
func validRect(_ rect: CGRect?) -> Bool {
|
guard let rect else { return false }
|
return [rect.origin.x, rect.origin.y, rect.size.width, rect.size.height].allSatisfy(\.isFinite)
|
&& rect.size.width > 0 && rect.size.height > 0
|
}
|
|
func isIsolationReadbackCompatible(
|
exactUniqueBound: Bool,
|
minimized: Bool?,
|
windowRect: CGRect?,
|
displayBounds: [CGRect]
|
) -> Bool {
|
guard exactUniqueBound, minimized == false,
|
let windowRect, validRect(windowRect), !displayBounds.isEmpty,
|
displayBounds.allSatisfy({ validRect($0) }) else { return false }
|
let center = CGPoint(x: windowRect.midX, y: windowRect.midY)
|
return displayBounds.contains(where: { $0.contains(center) })
|
}
|
|
func postMutationReadbackExit(
|
_ readback: Result<Bool, AXReadFailure>,
|
validationFailure: Int32,
|
cleanupFailure: Int32,
|
rollback: () -> Bool
|
) -> Int32? {
|
if case .success(true) = readback { return nil }
|
return rollback() ? validationFailure : cleanupFailure
|
}
|
|
func runIsolationMutationCore(
|
otherWindowCount: Int,
|
minimizeOther: (Int) -> Bool,
|
unminimizeSource: () -> Bool,
|
setSourceSize: () -> Bool,
|
setSourcePosition: () -> Bool,
|
raiseSource: () -> Bool,
|
beforeReadback: () -> Void,
|
readback: () -> Result<Bool, AXReadFailure>
|
) -> IsolationMutationResult {
|
for index in 0..<otherWindowCount {
|
guard minimizeOther(index) else { return .failure(.otherWindowMinimizeSetFailed) }
|
}
|
guard unminimizeSource() else { return .failure(.sourceUnminimizeSetFailed) }
|
guard setSourceSize() else { return .failure(.sourceSizeSetFailed) }
|
guard setSourcePosition() else { return .failure(.sourcePositionSetFailed) }
|
guard raiseSource() else { return .failure(.sourceRaiseFailed) }
|
beforeReadback()
|
switch readback() {
|
case .failure: return .failure(.sourceReadbackAXFailed)
|
case .success(true): return .success
|
case .success(false): return .failure(.sourceReadbackMismatch)
|
}
|
}
|
|
func finishIsolationFailure(
|
_ stage: IsolationFailureStage,
|
rollback: () -> Bool
|
) -> IsolationFailureResult {
|
let rollbackComplete = rollback()
|
return IsolationFailureResult(
|
line: "stage=\(stage.rawValue) rollback=\(rollbackComplete ? "PASS" : "FAIL")",
|
exitCode: rollbackComplete ? 72 : 73
|
)
|
}
|
|
func countExactSourceCore<Node>(
|
_ node: Node,
|
depth: Int = 0,
|
depthLimit: Int,
|
matches: (Node) throws -> Bool,
|
children: (Node) throws -> [Node]
|
) throws -> Int {
|
var count = try matches(node) ? 1 : 0
|
let childNodes = try children(node)
|
if depth == depthLimit {
|
guard childNodes.isEmpty else { throw AXReadFailure.traversalLimit }
|
return count
|
}
|
guard depth < depthLimit else { throw AXReadFailure.traversalLimit }
|
for child in childNodes {
|
count += try countExactSourceCore(
|
child,
|
depth: depth + 1,
|
depthLimit: depthLimit,
|
matches: matches,
|
children: children
|
)
|
}
|
return count
|
}
|
|
func selfTest() -> Int32 {
|
enum StateFixtureError: Error { case expected }
|
func isTraversalLimit(_ result: Result<Int, Error>) -> Bool {
|
guard case .failure(let error) = result,
|
let failure = error as? AXReadFailure else { return false }
|
if case .traversalLimit = failure { return true }
|
return false
|
}
|
struct TraversalNode {
|
let matches: Bool
|
let children: [Int]
|
}
|
let limit = 14
|
var shallowNodes = [TraversalNode(matches: false, children: [1])]
|
shallowNodes.append(TraversalNode(matches: true, children: []))
|
let shallowUnique = try? countExactSourceCore(
|
0,
|
depthLimit: limit,
|
matches: { shallowNodes[$0].matches },
|
children: { shallowNodes[$0].children }
|
)
|
let boundaryLeafNodes = (0...limit).map { depth in
|
TraversalNode(matches: depth == limit, children: depth == limit ? [] : [depth + 1])
|
}
|
let boundaryLeaf = try? countExactSourceCore(
|
0,
|
depthLimit: limit,
|
matches: { boundaryLeafNodes[$0].matches },
|
children: { boundaryLeafNodes[$0].children }
|
)
|
var truncatedNodes = boundaryLeafNodes
|
truncatedNodes[limit] = TraversalNode(matches: false, children: [limit + 1])
|
truncatedNodes.append(TraversalNode(matches: true, children: []))
|
var truncatedReads = 0
|
let truncatedResult = Result {
|
try countExactSourceCore(
|
0,
|
depthLimit: limit,
|
matches: { truncatedReads += 1; return truncatedNodes[$0].matches },
|
children: { truncatedReads += 1; return truncatedNodes[$0].children }
|
)
|
}
|
var hiddenDuplicateNodes = [TraversalNode(matches: false, children: [1, 2])]
|
hiddenDuplicateNodes.append(TraversalNode(matches: true, children: []))
|
let chainStart = hiddenDuplicateNodes.count
|
for depth in 1...limit {
|
hiddenDuplicateNodes.append(TraversalNode(matches: false, children: [chainStart + depth]))
|
}
|
hiddenDuplicateNodes.append(TraversalNode(matches: true, children: []))
|
var hiddenDuplicateTerminalReads = 0
|
let hiddenDuplicateResult = Result {
|
try countExactSourceCore(
|
0,
|
depthLimit: limit,
|
matches: { hiddenDuplicateTerminalReads += 1; return hiddenDuplicateNodes[$0].matches },
|
children: { hiddenDuplicateTerminalReads += 1; return hiddenDuplicateNodes[$0].children }
|
)
|
}
|
let expectedStageCases: [(String, IsolationFailureStage, [String])] = [
|
("other-1", .otherWindowMinimizeSetFailed, ["other-0", "other-1"]),
|
("unminimize", .sourceUnminimizeSetFailed, ["other-0", "other-1", "unminimize"]),
|
("size", .sourceSizeSetFailed, ["other-0", "other-1", "unminimize", "size"]),
|
("position", .sourcePositionSetFailed, ["other-0", "other-1", "unminimize", "size", "position"]),
|
("raise", .sourceRaiseFailed, ["other-0", "other-1", "unminimize", "size", "position", "raise"])
|
]
|
var stageCasesPass = true
|
for (failedOperation, expectedStage, expectedCalls) in expectedStageCases {
|
var calls: [String] = []
|
let result = runIsolationMutationCore(
|
otherWindowCount: 2,
|
minimizeOther: { index in calls.append("other-\(index)"); return "other-\(index)" != failedOperation },
|
unminimizeSource: { calls.append("unminimize"); return failedOperation != "unminimize" },
|
setSourceSize: { calls.append("size"); return failedOperation != "size" },
|
setSourcePosition: { calls.append("position"); return failedOperation != "position" },
|
raiseSource: { calls.append("raise"); return failedOperation != "raise" },
|
beforeReadback: { calls.append("wait") },
|
readback: { calls.append("readback"); return .success(true) }
|
)
|
stageCasesPass = stageCasesPass
|
&& result == .failure(expectedStage)
|
&& calls == expectedCalls
|
}
|
var readErrorCalls: [String] = []
|
let readErrorStage = runIsolationMutationCore(
|
otherWindowCount: 0,
|
minimizeOther: { _ in readErrorCalls.append("other"); return true },
|
unminimizeSource: { readErrorCalls.append("unminimize"); return true },
|
setSourceSize: { readErrorCalls.append("size"); return true },
|
setSourcePosition: { readErrorCalls.append("position"); return true },
|
raiseSource: { readErrorCalls.append("raise"); return true },
|
beforeReadback: { readErrorCalls.append("wait") },
|
readback: { readErrorCalls.append("readback"); return .failure(.nonBenign(.cannotComplete)) }
|
)
|
var mismatchCalls: [String] = []
|
let mismatchStage = runIsolationMutationCore(
|
otherWindowCount: 0,
|
minimizeOther: { _ in mismatchCalls.append("other"); return true },
|
unminimizeSource: { mismatchCalls.append("unminimize"); return true },
|
setSourceSize: { mismatchCalls.append("size"); return true },
|
setSourcePosition: { mismatchCalls.append("position"); return true },
|
raiseSource: { mismatchCalls.append("raise"); return true },
|
beforeReadback: { mismatchCalls.append("wait") },
|
readback: { mismatchCalls.append("readback"); return .success(false) }
|
)
|
var successCalls: [String] = []
|
let successStage = runIsolationMutationCore(
|
otherWindowCount: 1,
|
minimizeOther: { index in successCalls.append("other-\(index)"); return true },
|
unminimizeSource: { successCalls.append("unminimize"); return true },
|
setSourceSize: { successCalls.append("size"); return true },
|
setSourcePosition: { successCalls.append("position"); return true },
|
raiseSource: { successCalls.append("raise"); return true },
|
beforeReadback: { successCalls.append("wait") },
|
readback: { successCalls.append("readback"); return .success(true) }
|
)
|
var rollbackPassCalls = 0
|
let rollbackPass = finishIsolationFailure(.sourcePositionSetFailed) {
|
rollbackPassCalls += 1
|
return true
|
}
|
var rollbackFailCalls = 0
|
let rollbackFail = finishIsolationFailure(.sourceReadbackAXFailed) {
|
rollbackFailCalls += 1
|
return false
|
}
|
let displayBounds = [CGRect(x: 0, y: 0, width: 1920, height: 1080)]
|
let finderNormalizedRect = CGRect(x: 18, y: 62, width: 497, height: 325)
|
let invalidReadbackRects: [CGRect?] = [
|
nil,
|
.zero,
|
CGRect(x: 10, y: 70, width: 0, height: 320),
|
CGRect(x: 10, y: 70, width: 500, height: -1),
|
CGRect(x: CGFloat.nan, y: 70, width: 500, height: 320),
|
CGRect(x: 10, y: CGFloat.infinity, width: 500, height: 320),
|
CGRect(x: 2500, y: 70, width: 500, height: 320),
|
CGRect(x: -499, y: 70, width: 500, height: 320),
|
]
|
let normalizedReadbackAccepted = isIsolationReadbackCompatible(
|
exactUniqueBound: true,
|
minimized: false,
|
windowRect: finderNormalizedRect,
|
displayBounds: displayBounds
|
)
|
let tinyPositiveOnscreenAccepted = isIsolationReadbackCompatible(
|
exactUniqueBound: true,
|
minimized: false,
|
windowRect: CGRect(x: 1, y: 1, width: 1, height: 1),
|
displayBounds: displayBounds
|
)
|
let invalidReadbacksRejected = invalidReadbackRects.allSatisfy {
|
!isIsolationReadbackCompatible(
|
exactUniqueBound: true,
|
minimized: false,
|
windowRect: $0,
|
displayBounds: displayBounds
|
)
|
}
|
let invalidDisplayBounds = [
|
CGRect.zero,
|
CGRect(x: 0, y: 0, width: -1, height: 100),
|
CGRect(x: CGFloat.nan, y: 0, width: 100, height: 100),
|
CGRect(x: 0, y: CGFloat.infinity, width: 100, height: 100),
|
]
|
let mixedInvalidDisplaysRejected = invalidDisplayBounds.allSatisfy { invalidDisplay in
|
!isIsolationReadbackCompatible(
|
exactUniqueBound: true,
|
minimized: false,
|
windowRect: finderNormalizedRect,
|
displayBounds: [invalidDisplay, displayBounds[0]]
|
)
|
}
|
let pureInvalidDisplaysRejected = invalidDisplayBounds.allSatisfy { invalidDisplay in
|
!isIsolationReadbackCompatible(
|
exactUniqueBound: true,
|
minimized: false,
|
windowRect: finderNormalizedRect,
|
displayBounds: [invalidDisplay]
|
)
|
}
|
let fourDirectionDisplays = [
|
CGRect(x: -100, y: 0, width: 100, height: 100),
|
CGRect(x: 0, y: 0, width: 100, height: 100),
|
CGRect(x: 100, y: 0, width: 100, height: 100),
|
CGRect(x: 0, y: -100, width: 100, height: 100),
|
CGRect(x: 0, y: 100, width: 100, height: 100),
|
]
|
let fourDirectionCentersAccepted = [
|
CGPoint(x: -50, y: 50),
|
CGPoint(x: 150, y: 50),
|
CGPoint(x: 50, y: -50),
|
CGPoint(x: 50, y: 150),
|
].allSatisfy { center in
|
isIsolationReadbackCompatible(
|
exactUniqueBound: true,
|
minimized: false,
|
windowRect: CGRect(x: center.x - 10, y: center.y - 10, width: 20, height: 20),
|
displayBounds: fourDirectionDisplays
|
)
|
}
|
let validDisplaysOffscreenRejected = !isIsolationReadbackCompatible(
|
exactUniqueBound: true,
|
minimized: false,
|
windowRect: CGRect(x: 300, y: 300, width: 20, height: 20),
|
displayBounds: fourDirectionDisplays
|
)
|
let sourceWithoutID = WindowState(
|
windowID: nil,
|
x: 10,
|
y: 20,
|
width: 500,
|
height: 320,
|
minimized: false,
|
source: true
|
)
|
let goodRect = CGRect(x: 10, y: 20, width: 500, height: 320)
|
var sourceIDReads = 0
|
let isolationResult = buildIsolationPlan(
|
sourceIndex: 1,
|
windowCount: 3,
|
windowID: { index in
|
if index == 1 { sourceIDReads += 1; return .success(nil) }
|
return index == 0 ? .success(10) : .success(nil)
|
},
|
rect: { _ in .success(goodRect) },
|
minimized: { _ in .success(false) }
|
)
|
guard case .success(let isolationPlan) = isolationResult else { return 1 }
|
let duplicateResult = buildIsolationPlan(
|
sourceIndex: 1,
|
windowCount: 3,
|
windowID: { $0 == 1 ? .success(nil) : .success(10) },
|
rect: { _ in .success(goodRect) },
|
minimized: { _ in .success(false) }
|
)
|
let restoreResult = buildRestorePlan(
|
states: isolationPlan.states,
|
sourceIndex: 1,
|
windowCount: 3,
|
windowID: { $0 == 0 ? .success(10) : .success(nil) },
|
sourceRect: { .success(goodRect) },
|
sourceMinimized: { .success(false) }
|
)
|
guard case .success(let restorePlan) = restoreResult else { return 1 }
|
var restoreCalls: [Int] = []
|
let restoreComplete = restoreRecorded(restorePlan) { _, index in restoreCalls.append(index); return true }
|
var failedRestoreCalls: [Int] = []
|
let restoreIncomplete = restoreRecorded(restorePlan) { _, index in
|
failedRestoreCalls.append(index)
|
return index != 1
|
}
|
var terminalIDReads = 0
|
let terminalResult = buildIsolationPlan(
|
sourceIndex: 0,
|
windowCount: 4,
|
windowID: { index in
|
terminalIDReads += 1
|
if index == 1 || index == 2 { return .success(10) }
|
return .success(11)
|
},
|
rect: { _ in .success(goodRect) },
|
minimized: { _ in .success(false) }
|
)
|
var restoreTerminalIDReads = 0
|
let restoreTerminalResult = buildRestorePlan(
|
states: [sourceWithoutID],
|
sourceIndex: 0,
|
windowCount: 4,
|
windowID: { index in
|
restoreTerminalIDReads += 1
|
if index == 1 || index == 2 { return .success(10) }
|
return .success(11)
|
},
|
sourceRect: { .success(goodRect) },
|
sourceMinimized: { .success(false) }
|
)
|
let traversalErrorRejected: Bool
|
do {
|
_ = try uniqueSourceWindow(.failure(.nonBenign(.cannotComplete)))
|
traversalErrorRejected = false
|
} catch {
|
traversalErrorRejected = true
|
}
|
var rollbackCalled = 0
|
let readErrorCleanupSuccess = postMutationReadbackExit(
|
.failure(.nonBenign(.cannotComplete)), validationFailure: 72, cleanupFailure: 73
|
) { rollbackCalled += 1; return true }
|
let readErrorCleanupFailure = postMutationReadbackExit(
|
.failure(.nonBenign(.cannotComplete)), validationFailure: 72, cleanupFailure: 73
|
) { rollbackCalled += 1; return false }
|
var persistedBytes = Data()
|
let persistenceSuccess = persistStateSnapshot(
|
encode: { Data("state".utf8) },
|
atomicWrite: { persistedBytes = $0 }
|
)
|
let persistenceEncodeFailure = persistStateSnapshot(
|
encode: { throw StateFixtureError.expected },
|
atomicWrite: { _ in fatalError("write must not run after encode failure") }
|
)
|
let persistenceWriteFailure = persistStateSnapshot(
|
encode: { Data("state".utf8) },
|
atomicWrite: { _ in throw StateFixtureError.expected }
|
)
|
guard mixedInvalidDisplaysRejected,
|
pureInvalidDisplaysRejected,
|
fourDirectionCentersAccepted,
|
validDisplaysOffscreenRejected,
|
normalizedReadbackAccepted,
|
tinyPositiveOnscreenAccepted,
|
invalidReadbacksRejected,
|
!isIsolationReadbackCompatible(exactUniqueBound: false, minimized: false, windowRect: finderNormalizedRect, displayBounds: displayBounds),
|
!isIsolationReadbackCompatible(exactUniqueBound: true, minimized: nil, windowRect: finderNormalizedRect, displayBounds: displayBounds),
|
!isIsolationReadbackCompatible(exactUniqueBound: true, minimized: true, windowRect: finderNormalizedRect, displayBounds: displayBounds),
|
!isIsolationReadbackCompatible(exactUniqueBound: true, minimized: false, windowRect: finderNormalizedRect, displayBounds: []),
|
stageCasesPass,
|
readErrorStage == .failure(.sourceReadbackAXFailed),
|
readErrorCalls == ["unminimize", "size", "position", "raise", "wait", "readback"],
|
mismatchStage == .failure(.sourceReadbackMismatch),
|
mismatchCalls == ["unminimize", "size", "position", "raise", "wait", "readback"],
|
successStage == .success,
|
successCalls == ["other-0", "unminimize", "size", "position", "raise", "wait", "readback"],
|
rollbackPassCalls == 1,
|
rollbackPass.exitCode == 72,
|
rollbackPass.line == "stage=SOURCE_POSITION_SET_FAILED rollback=PASS",
|
rollbackFailCalls == 1,
|
rollbackFail.exitCode == 73,
|
rollbackFail.line == "stage=SOURCE_READBACK_AX_FAILED rollback=FAIL",
|
shallowUnique == 1,
|
boundaryLeaf == 1,
|
isTraversalLimit(truncatedResult),
|
truncatedReads == 30,
|
isTraversalLimit(hiddenDuplicateResult),
|
hiddenDuplicateTerminalReads == 32,
|
sourceWithoutID.windowID == nil,
|
sourceIDReads == 0,
|
isolationPlan.states.count == 2,
|
isolationPlan.states[0].source,
|
isolationPlan.states[0].windowID == nil,
|
isolationPlan.windowIndices == [1, 0],
|
isolationPlan.states[1].windowID == 10,
|
{ if case .failure(.duplicateNonSourceID) = duplicateResult { return true }; return false }(),
|
restorePlan.windowIndices == [1, 0],
|
restorePlan.states.map(\.source) == [true, false],
|
restoreComplete, restoreCalls == [1, 0],
|
!restoreIncomplete, failedRestoreCalls == [1, 0],
|
{ if case .failure(.duplicateNonSourceID) = terminalResult { return true }; return false }(),
|
terminalIDReads == 2,
|
{ if case .failure(.duplicateNonSourceID) = restoreTerminalResult { return true }; return false }(),
|
restoreTerminalIDReads == 2,
|
try! uniqueSourceWindow(.success([0, 1, 0])) == 1,
|
try! uniqueSourceWindow(.success([0, 0])) == nil,
|
try! uniqueSourceWindow(.success([1, 1])) == nil,
|
traversalErrorRejected,
|
isBenignAbsence(.noValue), isBenignAbsence(.attributeUnsupported),
|
!isBenignAbsence(.cannotComplete), !isBenignAbsence(.invalidUIElement), !isBenignAbsence(.apiDisabled),
|
validRect(CGRect(x: 1, y: 2, width: 3, height: 4)),
|
!validRect(.zero),
|
RestoreSummary(mutableRecorded: 2, restored: 2, mutationFailures: 0).exitCode == 0,
|
RestoreSummary(mutableRecorded: 2, restored: 1, mutationFailures: 0).exitCode != 0,
|
RestoreSummary(mutableRecorded: 2, restored: 2, mutationFailures: 1).exitCode != 0,
|
rollbackCalled == 2, readErrorCleanupSuccess == 72, readErrorCleanupFailure == 73,
|
postMutationReadbackExit(.success(true), validationFailure: 72, cleanupFailure: 73, rollback: { false }) == nil,
|
preStateFailureLine(.finderNotRunning) == "stage=FINDER_NOT_RUNNING mutation=0",
|
preStateFailureLine(.finderWindowsReadFailed) == "stage=FINDER_WINDOWS_READ_FAILED mutation=0",
|
{ if case .success = persistenceSuccess { return true }; return false }(),
|
persistedBytes == Data("state".utf8),
|
{ if case .failure(.encode) = persistenceEncodeFailure { return true }; return false }(),
|
{ if case .failure(.atomicWrite) = persistenceWriteFailure { return true }; return false }(),
|
StatePersistenceFailure.encode.stage == .stateEncodeFailed,
|
StatePersistenceFailure.atomicWrite.stage == .stateAtomicWriteFailed else { return 1 }
|
print("self_test=PASS exact_unique_window=true traversal_read_error_rejected=true post_mutation_read_error_rollback=true cleanup_status_distinct=true pre_state_observability=true state_write_classification=true")
|
return 0
|
}
|
|
if CommandLine.arguments == [CommandLine.arguments[0], "--self-test"] { exit(selfTest()) }
|
guard CommandLine.arguments.count == 4,
|
["isolate", "restore"].contains(CommandLine.arguments[1]),
|
!CommandLine.arguments[2].isEmpty,
|
!CommandLine.arguments[3].isEmpty else {
|
fputs("usage: FinderWindowIsolation isolate|restore state.json exactSourceIdentifier\n", stderr)
|
exit(64)
|
}
|
let mode = CommandLine.arguments[1]
|
let stateURL = URL(fileURLWithPath: CommandLine.arguments[2])
|
let exactSourceIdentifier = CommandLine.arguments[3]
|
let axWindowNumberAttribute = "AXWindowNumber"
|
|
func attr(_ element: AXUIElement, _ name: String) throws -> CFTypeRef? {
|
var value: CFTypeRef?
|
let error = AXUIElementCopyAttributeValue(element, name as CFString, &value)
|
if error == .success { return value }
|
if isBenignAbsence(error) { return nil }
|
throw AXReadFailure.nonBenign(error)
|
}
|
func text(_ element: AXUIElement, _ name: String) throws -> String? {
|
guard let value = try attr(element, name), CFGetTypeID(value) == CFStringGetTypeID() else { return nil }
|
return value as? String
|
}
|
func bool(_ element: AXUIElement, _ name: String) throws -> Bool? {
|
guard let value = try attr(element, name), CFGetTypeID(value) == CFBooleanGetTypeID() else { return nil }
|
return CFBooleanGetValue((value as! CFBoolean))
|
}
|
func number(_ element: AXUIElement, _ name: String) throws -> Int64? {
|
guard let value = try attr(element, name), CFGetTypeID(value) == CFNumberGetTypeID() else { return nil }
|
var result: Int64 = 0
|
return CFNumberGetValue((value as! CFNumber), .sInt64Type, &result) ? result : nil
|
}
|
func rect(_ element: AXUIElement) throws -> CGRect? {
|
guard let pv = try attr(element, kAXPositionAttribute), CFGetTypeID(pv) == AXValueGetTypeID(),
|
let sv = try attr(element, kAXSizeAttribute), CFGetTypeID(sv) == AXValueGetTypeID() else { return nil }
|
var point = CGPoint.zero
|
var size = CGSize.zero
|
guard AXValueGetValue(pv as! AXValue, .cgPoint, &point),
|
AXValueGetValue(sv as! AXValue, .cgSize, &size) else { return nil }
|
return CGRect(origin: point, size: size)
|
}
|
func activeDisplayBounds() -> [CGRect]? {
|
var count: UInt32 = 0
|
guard CGGetActiveDisplayList(0, nil, &count) == .success, count > 0 else { return nil }
|
var identifiers = [CGDirectDisplayID](repeating: 0, count: Int(count))
|
guard CGGetActiveDisplayList(count, &identifiers, &count) == .success else { return nil }
|
return identifiers.prefix(Int(count)).map(CGDisplayBounds)
|
}
|
func countExactSource(_ element: AXUIElement, depth: Int = 0) throws -> Int {
|
try countExactSourceCore(
|
element,
|
depth: depth,
|
depthLimit: 14,
|
matches: {
|
try text($0, kAXRoleAttribute) == (kAXTextFieldRole as String)
|
&& text($0, kAXValueAttribute) == exactSourceIdentifier
|
},
|
children: { try attr($0, kAXChildrenAttribute) as? [AXUIElement] ?? [] }
|
)
|
}
|
func readResult<Value>(_ body: () throws -> Value) -> Result<Value, AXReadFailure> {
|
do { return .success(try body()) }
|
catch let failure as AXReadFailure { return .failure(failure) }
|
catch { return .failure(.nonBenign(.failure)) }
|
}
|
func setBool(_ element: AXUIElement, _ name: String, _ value: Bool) -> AXError {
|
AXUIElementSetAttributeValue(element, name as CFString, value as CFBoolean)
|
}
|
func setPoint(_ element: AXUIElement, _ value: CGPoint) -> AXError {
|
var value = value
|
return AXUIElementSetAttributeValue(element, kAXPositionAttribute as CFString, AXValueCreate(.cgPoint, &value)!)
|
}
|
func setSize(_ element: AXUIElement, _ value: CGSize) -> AXError {
|
var value = value
|
return AXUIElementSetAttributeValue(element, kAXSizeAttribute as CFString, AXValueCreate(.cgSize, &value)!)
|
}
|
func restore(_ state: WindowState, to window: AXUIElement) -> Bool {
|
var success = true
|
if state.source {
|
success = setSize(window, CGSize(width: state.width, height: state.height)) == .success && success
|
success = setPoint(window, CGPoint(x: state.x, y: state.y)) == .success && success
|
}
|
success = setBool(window, kAXMinimizedAttribute, state.minimized) == .success && success
|
return success
|
}
|
|
guard let finder = NSRunningApplication.runningApplications(withBundleIdentifier: "com.apple.finder").first else {
|
fputs("\(preStateFailureLine(.finderNotRunning))\n", stderr)
|
exit(66)
|
}
|
let app = AXUIElementCreateApplication(finder.processIdentifier)
|
let windows: [AXUIElement]
|
do {
|
guard let value = try attr(app, kAXWindowsAttribute) as? [AXUIElement] else {
|
fputs("\(preStateFailureLine(.finderWindowsReadFailed))\n", stderr)
|
exit(67)
|
}
|
windows = value
|
} catch {
|
fputs("\(preStateFailureLine(.finderWindowsReadFailed))\n", stderr)
|
exit(67)
|
}
|
|
if mode == "isolate" {
|
let matchCounts: Result<[Int], AXReadFailure>
|
do { matchCounts = .success(try windows.map { try countExactSource($0) }) }
|
catch let failure as AXReadFailure { matchCounts = .failure(failure) }
|
guard let sourceIndex = try? uniqueSourceWindow(matchCounts) else {
|
fputs("exact source must bind to exactly one Finder window\n", stderr)
|
exit(68)
|
}
|
|
let planResult = buildIsolationPlan(
|
sourceIndex: sourceIndex,
|
windowCount: windows.count,
|
windowID: { index in readResult { try number(windows[index], axWindowNumberAttribute) } },
|
rect: { index in readResult { try rect(windows[index]) } },
|
minimized: { index in readResult { try bool(windows[index], kAXMinimizedAttribute) } }
|
)
|
guard case .success(let plan) = planResult else {
|
fputs("source binding or non-source identity failed closed\n", stderr)
|
exit(69)
|
}
|
let source = windows[sourceIndex]
|
let persistence = persistStateSnapshot(
|
encode: { try JSONEncoder().encode(plan.states) },
|
atomicWrite: { try $0.write(to: stateURL, options: .atomic) }
|
)
|
if case .failure(let failure) = persistence {
|
fputs("\(preStateFailureLine(failure.stage))\n", stderr)
|
exit(70)
|
}
|
|
let otherWindowIndices = zip(plan.states, plan.windowIndices).compactMap { state, index in
|
state.source ? nil : index
|
}
|
let mutationResult = runIsolationMutationCore(
|
otherWindowCount: otherWindowIndices.count,
|
minimizeOther: { index in
|
setBool(windows[otherWindowIndices[index]], kAXMinimizedAttribute, true) == .success
|
},
|
unminimizeSource: { setBool(source, kAXMinimizedAttribute, false) == .success },
|
setSourceSize: { setSize(source, CGSize(width: 500, height: 320)) == .success },
|
setSourcePosition: { setPoint(source, CGPoint(x: 10, y: 70)) == .success },
|
raiseSource: { AXUIElementPerformAction(source, kAXRaiseAction as CFString) == .success },
|
beforeReadback: { Thread.sleep(forTimeInterval: 0.8) },
|
readback: {
|
readResult {
|
isIsolationReadbackCompatible(
|
exactUniqueBound: true,
|
minimized: try bool(source, kAXMinimizedAttribute),
|
windowRect: try rect(source),
|
displayBounds: activeDisplayBounds() ?? []
|
)
|
}
|
}
|
)
|
if case .failure(let stage) = mutationResult {
|
let failure = finishIsolationFailure(stage) {
|
restoreRecorded(plan) { state, index in restore(state, to: windows[index]) }
|
}
|
fputs("\(failure.line)\n", stderr)
|
exit(failure.exitCode)
|
}
|
print("isolated_mutable_windows=\(plan.states.count) skipped_immutable_windows=\(windows.count - plan.states.count) source=<QA_WINDOW> readback=PASS")
|
} else {
|
let states = try JSONDecoder().decode([WindowState].self, from: Data(contentsOf: stateURL))
|
let matchCounts: Result<[Int], AXReadFailure>
|
do { matchCounts = .success(try windows.map { try countExactSource($0) }) }
|
catch let failure as AXReadFailure { matchCounts = .failure(failure) }
|
let sourceIndex = try? uniqueSourceWindow(matchCounts)
|
let planResult = buildRestorePlan(
|
states: states,
|
sourceIndex: sourceIndex,
|
windowCount: windows.count,
|
windowID: { index in readResult { try number(windows[index], axWindowNumberAttribute) } },
|
sourceRect: {
|
guard let sourceIndex else { return .success(nil) }
|
return readResult { try rect(windows[sourceIndex]) }
|
},
|
sourceMinimized: {
|
guard let sourceIndex else { return .success(nil) }
|
return readResult { try bool(windows[sourceIndex], kAXMinimizedAttribute) }
|
}
|
)
|
guard case .success(let plan) = planResult else {
|
fputs("Finder restore binding failed closed\n", stderr)
|
exit(75)
|
}
|
var restored = 0
|
var failures = 0
|
for (state, index) in zip(plan.states, plan.windowIndices) {
|
if restore(state, to: windows[index]) { restored += 1 } else { failures += 1 }
|
}
|
let summary = RestoreSummary(mutableRecorded: plan.states.count, restored: restored, mutationFailures: failures)
|
print("restored=\(summary.restored) mutable_recorded=\(summary.mutableRecorded) failures=\(summary.mutationFailures)")
|
exit(summary.exitCode)
|
}
|
