import AppKit
|
import ApplicationServices
|
import CryptoKit
|
import Darwin
|
import Foundation
|
|
func validDrag(start: CGPoint, end: CGPoint, displays: [CGRect]) -> Bool {
|
let values = [start.x, start.y, end.x, end.y]
|
guard values.allSatisfy(\.isFinite), start != end, !displays.isEmpty else { return false }
|
return displays.contains(where: { $0.contains(start) }) && displays.contains(where: { $0.contains(end) })
|
}
|
|
struct ReceiverIdentity: Equatable {
|
let pid: Int32
|
let windowID: UInt32
|
}
|
|
struct WindowSnapshot {
|
let identity: ReceiverIdentity
|
let layer: Int
|
let bounds: CGRect
|
let alpha: Double
|
let onScreen: Bool
|
}
|
|
struct SourceIdentity: Equatable {
|
let byteCount: Int64
|
let digest: String
|
let device: UInt64
|
let inode: UInt64
|
|
init(byteCount: Int64, digest: String, device: UInt64 = 0, inode: UInt64 = 0) {
|
self.byteCount = byteCount
|
self.digest = digest
|
self.device = device
|
self.inode = inode
|
}
|
}
|
|
func validRect(_ rect: CGRect) -> Bool {
|
[rect.origin.x, rect.origin.y, rect.size.width, rect.size.height].allSatisfy(\.isFinite)
|
&& rect.size.width > 0 && rect.size.height > 0
|
}
|
|
func topReceiver(at point: CGPoint, expectedPID: Int32, windows: [WindowSnapshot]) -> ReceiverIdentity? {
|
guard expectedPID > 0, !windows.isEmpty,
|
windows.allSatisfy({ snapshot in
|
snapshot.identity.pid > 0 && snapshot.identity.windowID > 0
|
&& snapshot.alpha.isFinite && snapshot.alpha >= 0 && snapshot.alpha <= 1
|
&& validRect(snapshot.bounds)
|
}) else { return nil }
|
guard let top = windows.first(where: { $0.onScreen && $0.alpha > 0 && $0.bounds.contains(point) }),
|
top.layer == 0, top.identity.pid == expectedPID else { return nil }
|
return top.identity
|
}
|
|
func receiverStable(preflight: ReceiverIdentity, beforeMouseUp: ReceiverIdentity?) -> Bool {
|
preflight == beforeMouseUp
|
}
|
|
func requiredDragFlags() -> CGEventFlags { [.maskAlternate] }
|
|
func validQASourceScope(
|
rootComponents: [String],
|
sourceComponents: [String],
|
rootIsDirectory: Bool,
|
rootIsSymlink: Bool,
|
sourceExists: Bool,
|
sourceIsRegular: Bool,
|
sourceIsSymlink: Bool,
|
sourceSize: Int64,
|
maximumSize: Int64
|
) -> Bool {
|
guard !rootComponents.isEmpty, sourceComponents.count > rootComponents.count,
|
Array(sourceComponents.prefix(rootComponents.count)) == rootComponents,
|
rootIsDirectory, !rootIsSymlink, sourceExists, sourceIsRegular, !sourceIsSymlink,
|
sourceSize >= 0, maximumSize > 0, sourceSize <= maximumSize else { return false }
|
return true
|
}
|
|
func sourcePreserved(before: SourceIdentity, after: SourceIdentity?) -> Bool { before == after }
|
|
enum SourceCleanupResult: Equatable {
|
case preserved
|
case recovered
|
case failed
|
}
|
|
func sourceCleanupResult(
|
before: SourceIdentity,
|
after: SourceIdentity?,
|
restore: () -> Bool
|
) -> SourceCleanupResult {
|
if sourcePreserved(before: before, after: after) { return .preserved }
|
return restore() ? .recovered : .failed
|
}
|
|
func makeCopyMouseEvent(source: CGEventSource?, type: CGEventType, point: CGPoint) -> CGEvent? {
|
guard let event = CGEvent(
|
mouseEventSource: source,
|
mouseType: type,
|
mouseCursorPosition: point,
|
mouseButton: .left
|
) else { return nil }
|
event.flags = requiredDragFlags()
|
return event
|
}
|
|
func runSafeCancel(
|
escapeDown: () -> Bool,
|
escapeUp: () -> Bool,
|
mouseUp: () -> Bool
|
) -> Bool {
|
let down = escapeDown()
|
let up = escapeUp()
|
let released = mouseUp()
|
return down && up && released
|
}
|
|
struct CleanupState {
|
var mouseDownPosted = false
|
var mouseUpPosted = false
|
var cleanupAttempted = false
|
var cleanupSucceeded = false
|
|
mutating func failAfterMouseDown(cleanup: () -> Bool) -> Int32 {
|
guard mouseDownPosted && !mouseUpPosted else { return 70 }
|
cleanupAttempted = true
|
cleanupSucceeded = cleanup()
|
if cleanupSucceeded { mouseUpPosted = true }
|
return cleanupSucceeded ? 70 : 71
|
}
|
}
|
|
func selfTest() -> Int32 {
|
let bounds = [CGRect(x: 0, y: 0, width: 1920, height: 1080)]
|
let destination = CGPoint(x: 500, y: 500)
|
let candidate = ReceiverIdentity(pid: 42, windowID: 7)
|
let candidateWindow = WindowSnapshot(identity: candidate, layer: 0, bounds: CGRect(x: 400, y: 400, width: 300, height: 300), alpha: 1, onScreen: true)
|
let otherWindow = WindowSnapshot(identity: ReceiverIdentity(pid: 99, windowID: 8), layer: 0, bounds: candidateWindow.bounds, alpha: 1, onScreen: true)
|
let nonNormalWindow = WindowSnapshot(identity: ReceiverIdentity(pid: 42, windowID: 9), layer: 1, bounds: candidateWindow.bounds, alpha: 1, onScreen: true)
|
let invalidWindow = WindowSnapshot(identity: candidate, layer: 0, bounds: .zero, alpha: 1, onScreen: true)
|
let exactReceiver = topReceiver(at: destination, expectedPID: 42, windows: [candidateWindow])
|
let rootComponents = ["QA_ROOT"]
|
let sourceComponents = ["QA_ROOT", "SOURCE"]
|
let validSource = validQASourceScope(
|
rootComponents: rootComponents,
|
sourceComponents: sourceComponents,
|
rootIsDirectory: true,
|
rootIsSymlink: false,
|
sourceExists: true,
|
sourceIsRegular: true,
|
sourceIsSymlink: false,
|
sourceSize: 1024,
|
maximumSize: 16 * 1024 * 1024
|
)
|
let sourceBefore = SourceIdentity(byteCount: 1024, digest: "FIXTURE_DIGEST")
|
let builtCopyEvents = [CGEventType.leftMouseDown, .leftMouseDragged, .leftMouseUp].compactMap {
|
makeCopyMouseEvent(source: nil, type: $0, point: CGPoint(x: 1, y: 1))
|
}
|
var cancelCalls: [String] = []
|
let cancelComplete = runSafeCancel(
|
escapeDown: { cancelCalls.append("escape-down"); return true },
|
escapeUp: { cancelCalls.append("escape-up"); return true },
|
mouseUp: { cancelCalls.append("mouse-up"); return true }
|
)
|
var failedCancelCalls: [String] = []
|
let cancelIncomplete = runSafeCancel(
|
escapeDown: { failedCancelCalls.append("escape-down"); return false },
|
escapeUp: { failedCancelCalls.append("escape-up"); return true },
|
mouseUp: { failedCancelCalls.append("mouse-up"); return false }
|
)
|
guard validDrag(start: CGPoint(x: 1, y: 1), end: CGPoint(x: 2, y: 2), displays: bounds),
|
!validDrag(start: CGPoint(x: CGFloat.nan, y: 1), end: CGPoint(x: 2, y: 2), displays: bounds),
|
!validDrag(start: CGPoint(x: 1, y: 1), end: CGPoint(x: CGFloat.infinity, y: 2), displays: bounds),
|
!validDrag(start: CGPoint(x: 1, y: 1), end: CGPoint(x: 1, y: 1), displays: bounds),
|
!validDrag(start: CGPoint(x: -1, y: 1), end: CGPoint(x: 2, y: 2), displays: bounds),
|
exactReceiver == candidate,
|
topReceiver(at: destination, expectedPID: 42, windows: [otherWindow, candidateWindow]) == nil,
|
topReceiver(at: destination, expectedPID: 42, windows: []) == nil,
|
topReceiver(at: destination, expectedPID: 42, windows: [invalidWindow]) == nil,
|
topReceiver(at: destination, expectedPID: 42, windows: [nonNormalWindow, candidateWindow]) == nil,
|
topReceiver(at: destination, expectedPID: 7, windows: [candidateWindow]) == nil,
|
receiverStable(preflight: candidate, beforeMouseUp: candidate),
|
!receiverStable(preflight: candidate, beforeMouseUp: ReceiverIdentity(pid: 42, windowID: 10)),
|
requiredDragFlags().contains(.maskAlternate),
|
builtCopyEvents.count == 3,
|
builtCopyEvents.allSatisfy({ $0.flags.contains(.maskAlternate) }),
|
validSource,
|
!validQASourceScope(rootComponents: rootComponents, sourceComponents: ["OUTSIDE", "SOURCE"], rootIsDirectory: true, rootIsSymlink: false, sourceExists: true, sourceIsRegular: true, sourceIsSymlink: false, sourceSize: 1, maximumSize: 16),
|
!validQASourceScope(rootComponents: rootComponents, sourceComponents: sourceComponents, rootIsDirectory: true, rootIsSymlink: false, sourceExists: true, sourceIsRegular: true, sourceIsSymlink: true, sourceSize: 1, maximumSize: 16),
|
!validQASourceScope(rootComponents: rootComponents, sourceComponents: sourceComponents, rootIsDirectory: true, rootIsSymlink: false, sourceExists: false, sourceIsRegular: true, sourceIsSymlink: false, sourceSize: 1, maximumSize: 16),
|
!validQASourceScope(rootComponents: rootComponents, sourceComponents: sourceComponents, rootIsDirectory: true, rootIsSymlink: false, sourceExists: true, sourceIsRegular: false, sourceIsSymlink: false, sourceSize: 1, maximumSize: 16),
|
!validQASourceScope(rootComponents: rootComponents, sourceComponents: sourceComponents, rootIsDirectory: true, rootIsSymlink: false, sourceExists: true, sourceIsRegular: true, sourceIsSymlink: false, sourceSize: 17, maximumSize: 16),
|
sourcePreserved(before: sourceBefore, after: sourceBefore),
|
!sourcePreserved(before: sourceBefore, after: nil),
|
!sourcePreserved(before: sourceBefore, after: SourceIdentity(byteCount: 1024, digest: "CHANGED")),
|
sourceCleanupResult(before: sourceBefore, after: sourceBefore, restore: { false }) == .preserved,
|
sourceCleanupResult(before: sourceBefore, after: nil, restore: { true }) == .recovered,
|
sourceCleanupResult(before: sourceBefore, after: nil, restore: { false }) == .failed,
|
cancelComplete, cancelCalls == ["escape-down", "escape-up", "mouse-up"],
|
!cancelIncomplete, failedCancelCalls == ["escape-down", "escape-up", "mouse-up"] else { return 1 }
|
var recovered = CleanupState(mouseDownPosted: true)
|
guard recovered.failAfterMouseDown(cleanup: { true }) == 70,
|
recovered.cleanupAttempted, recovered.cleanupSucceeded, recovered.mouseUpPosted else { return 2 }
|
var failed = CleanupState(mouseDownPosted: true)
|
guard failed.failAfterMouseDown(cleanup: { false }) == 71,
|
failed.cleanupAttempted, !failed.cleanupSucceeded, !failed.mouseUpPosted else { return 3 }
|
print("self_test=PASS coordinate_validation=true mouse_up_cleanup=true")
|
return 0
|
}
|
|
if CommandLine.arguments == [CommandLine.arguments[0], "--self-test"] {
|
exit(selfTest())
|
}
|
|
guard CommandLine.arguments.count == 8,
|
let startX = Double(CommandLine.arguments[1]),
|
let startY = Double(CommandLine.arguments[2]),
|
let endX = Double(CommandLine.arguments[3]),
|
let endY = Double(CommandLine.arguments[4]),
|
let candidatePID = Int32(CommandLine.arguments[5]), candidatePID > 0,
|
!CommandLine.arguments[6].isEmpty,
|
!CommandLine.arguments[7].isEmpty else {
|
fputs("usage: NativeDrag startX startY endX endY candidatePID qaRoot qaSource\n", stderr)
|
exit(64)
|
}
|
|
let maximumSourceBytes: Int64 = 16 * 1024 * 1024
|
let rootInputURL = URL(fileURLWithPath: CommandLine.arguments[6]).standardizedFileURL
|
let sourceInputURL = URL(fileURLWithPath: CommandLine.arguments[7]).standardizedFileURL
|
let rootURL = rootInputURL.resolvingSymlinksInPath()
|
let sourceURL = sourceInputURL.resolvingSymlinksInPath()
|
|
func fileStatus(_ url: URL) -> stat? {
|
var value = stat()
|
return lstat(url.path, &value) == 0 ? value : nil
|
}
|
func isMode(_ status: stat, _ expected: mode_t) -> Bool {
|
status.st_mode & mode_t(S_IFMT) == expected
|
}
|
func digest(_ data: Data) -> String {
|
SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined()
|
}
|
func sourceIdentity(_ url: URL) -> SourceIdentity? {
|
guard let status = fileStatus(url), isMode(status, mode_t(S_IFREG)),
|
!isMode(status, mode_t(S_IFLNK)), status.st_size >= 0,
|
status.st_size <= maximumSourceBytes,
|
let data = try? Data(contentsOf: url, options: .mappedIfSafe),
|
data.count == Int(status.st_size) else { return nil }
|
return SourceIdentity(
|
byteCount: status.st_size,
|
digest: digest(data),
|
device: UInt64(status.st_dev),
|
inode: UInt64(status.st_ino)
|
)
|
}
|
func sourceScopeValid() -> Bool {
|
guard let rootStatus = fileStatus(rootInputURL), let sourceStatus = fileStatus(sourceInputURL) else { return false }
|
return validQASourceScope(
|
rootComponents: rootURL.pathComponents,
|
sourceComponents: sourceURL.pathComponents,
|
rootIsDirectory: isMode(rootStatus, mode_t(S_IFDIR)),
|
rootIsSymlink: isMode(rootStatus, mode_t(S_IFLNK)),
|
sourceExists: true,
|
sourceIsRegular: isMode(sourceStatus, mode_t(S_IFREG)),
|
sourceIsSymlink: isMode(sourceStatus, mode_t(S_IFLNK)),
|
sourceSize: sourceStatus.st_size,
|
maximumSize: maximumSourceBytes
|
)
|
}
|
guard sourceScopeValid(), let sourceBefore = sourceIdentity(sourceURL),
|
let sourcePreimage = try? Data(contentsOf: sourceURL),
|
sourcePreimage.count == Int(sourceBefore.byteCount) else {
|
fputs("qa source scope failed closed\n", stderr)
|
exit(64)
|
}
|
|
func restoreSourcePreimage() -> Bool {
|
let currentURL = sourceInputURL.resolvingSymlinksInPath()
|
guard Array(currentURL.pathComponents.prefix(rootURL.pathComponents.count)) == rootURL.pathComponents,
|
currentURL.pathComponents.count > rootURL.pathComponents.count else { return false }
|
if let currentStatus = fileStatus(sourceInputURL) {
|
guard isMode(currentStatus, mode_t(S_IFREG)), !isMode(currentStatus, mode_t(S_IFLNK)) else { return false }
|
}
|
do {
|
try sourcePreimage.write(to: sourceInputURL, options: .atomic)
|
guard let restored = sourceIdentity(sourceInputURL) else { return false }
|
return restored.byteCount == sourceBefore.byteCount && restored.digest == sourceBefore.digest
|
} catch {
|
return false
|
}
|
}
|
|
func windowSnapshots() -> [WindowSnapshot]? {
|
let options: CGWindowListOption = [.optionOnScreenOnly, .excludeDesktopElements]
|
guard let raw = CGWindowListCopyWindowInfo(options, kCGNullWindowID) as? [[String: Any]], !raw.isEmpty else { return nil }
|
var result: [WindowSnapshot] = []
|
for item in raw {
|
guard let pid = (item[kCGWindowOwnerPID as String] as? NSNumber)?.int32Value,
|
let windowID = (item[kCGWindowNumber as String] as? NSNumber)?.uint32Value,
|
let layer = (item[kCGWindowLayer as String] as? NSNumber)?.intValue,
|
let alpha = (item[kCGWindowAlpha as String] as? NSNumber)?.doubleValue,
|
let onScreen = (item[kCGWindowIsOnscreen as String] as? NSNumber)?.boolValue,
|
let boundsValue = item[kCGWindowBounds as String],
|
CFGetTypeID(boundsValue as CFTypeRef) == CFDictionaryGetTypeID(),
|
let bounds = CGRect(dictionaryRepresentation: boundsValue as! CFDictionary) else { return nil }
|
result.append(WindowSnapshot(
|
identity: ReceiverIdentity(pid: pid, windowID: windowID),
|
layer: layer,
|
bounds: bounds,
|
alpha: alpha,
|
onScreen: onScreen
|
))
|
}
|
return result
|
}
|
|
var displayCount: UInt32 = 0
|
guard CGGetActiveDisplayList(0, nil, &displayCount) == .success, displayCount > 0 else { exit(65) }
|
var displayIDs = [CGDirectDisplayID](repeating: 0, count: Int(displayCount))
|
guard CGGetActiveDisplayList(displayCount, &displayIDs, &displayCount) == .success else { exit(65) }
|
let frozenDisplayBounds = displayIDs.prefix(Int(displayCount)).map(CGDisplayBounds)
|
let start = CGPoint(x: startX, y: startY)
|
let end = CGPoint(x: endX, y: endY)
|
guard validDrag(start: start, end: end, displays: frozenDisplayBounds) else {
|
fputs("invalid or out-of-bounds drag coordinates\n", stderr)
|
exit(64)
|
}
|
|
let finderApplications = NSRunningApplication.runningApplications(withBundleIdentifier: "com.apple.finder")
|
guard NSRunningApplication(processIdentifier: candidatePID) != nil,
|
finderApplications.count == 1, let finder = finderApplications.first,
|
let preflightWindows = windowSnapshots(),
|
topReceiver(at: start, expectedPID: finder.processIdentifier, windows: preflightWindows) != nil,
|
let destinationReceiver = topReceiver(at: end, expectedPID: candidatePID, windows: preflightWindows) else {
|
fputs("delivery receiver preflight failed closed\n", stderr)
|
exit(65)
|
}
|
|
let trusted = AXIsProcessTrusted()
|
let postAllowed = CGPreflightPostEventAccess()
|
print("AXIsProcessTrusted=\(trusted)")
|
print("CGPreflightPostEventAccess=\(postAllowed)")
|
guard trusted && postAllowed else { exit(77) }
|
|
let source = CGEventSource(stateID: .hidSystemState)
|
func postMouse(_ type: CGEventType, at point: CGPoint) -> Bool {
|
guard let event = makeCopyMouseEvent(source: source, type: type, point: point) else { return false }
|
event.post(tap: .cghidEventTap)
|
return true
|
}
|
func postEscape(_ keyDown: Bool) -> Bool {
|
guard let event = CGEvent(keyboardEventSource: source, virtualKey: 53, keyDown: keyDown) else { return false }
|
event.post(tap: .cghidEventTap)
|
return true
|
}
|
func cancelDrag() -> Bool {
|
runSafeCancel(
|
escapeDown: { postEscape(true) },
|
escapeUp: { postEscape(false) },
|
mouseUp: { postMouse(.leftMouseUp, at: start) }
|
)
|
}
|
|
func terminateFailure(receiverIdentityPassed: Bool, cleanupComplete: Bool) -> Never {
|
let sourceResult = sourceCleanupResult(
|
before: sourceBefore,
|
after: sourceIdentity(sourceInputURL),
|
restore: restoreSourcePreimage
|
)
|
let sourceWasPreserved = sourceResult == .preserved
|
let complete = cleanupComplete && sourceResult != .failed
|
fputs(
|
"receiver_identity=\(receiverIdentityPassed ? "PASS" : "FAIL") copy_semantic=PASS source_preserved=\(sourceWasPreserved ? "PASS" : "FAIL") cleanup=\(complete ? "PASS" : "FAIL")\n",
|
stderr
|
)
|
exit(complete ? 70 : 71)
|
}
|
|
var lastPoint = start
|
guard postMouse(.mouseMoved, at: start) else { exit(70) }
|
Thread.sleep(forTimeInterval: 0.35)
|
guard postMouse(.leftMouseDown, at: start) else { exit(70) }
|
Thread.sleep(forTimeInterval: 0.45)
|
|
let steps = 36
|
for index in 1...steps {
|
let progress = Double(index) / Double(steps)
|
let eased = progress * progress * (3.0 - 2.0 * progress)
|
lastPoint = CGPoint(x: start.x + (end.x - start.x) * eased, y: start.y + (end.y - start.y) * eased)
|
guard postMouse(.leftMouseDragged, at: lastPoint) else {
|
terminateFailure(receiverIdentityPassed: false, cleanupComplete: cancelDrag())
|
}
|
Thread.sleep(forTimeInterval: 0.035)
|
}
|
|
Thread.sleep(forTimeInterval: 0.75)
|
let receiverBeforeMouseUp = windowSnapshots().flatMap {
|
topReceiver(at: end, expectedPID: candidatePID, windows: $0)
|
}
|
guard receiverStable(preflight: destinationReceiver, beforeMouseUp: receiverBeforeMouseUp) else {
|
terminateFailure(receiverIdentityPassed: false, cleanupComplete: cancelDrag())
|
}
|
guard postMouse(.leftMouseUp, at: end) else {
|
terminateFailure(receiverIdentityPassed: true, cleanupComplete: cancelDrag())
|
}
|
Thread.sleep(forTimeInterval: 0.5)
|
guard sourcePreserved(before: sourceBefore, after: sourceIdentity(sourceInputURL)) else {
|
terminateFailure(receiverIdentityPassed: true, cleanupComplete: true)
|
}
|
print("receiver_identity=PASS copy_semantic=PASS source_preserved=PASS cleanup=PASS")
|
