//go:build darwin
|
|
package axinput
|
|
/*
|
#cgo CFLAGS: -x objective-c
|
#cgo LDFLAGS: -framework AppKit -framework ApplicationServices
|
#include <ApplicationServices/ApplicationServices.h>
|
#include <AppKit/AppKit.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <unistd.h>
|
|
static char* pvAXCopyError(NSString* message) {
|
const char* utf8 = [message UTF8String];
|
if (!utf8) return strdup("unknown error");
|
return strdup(utf8);
|
}
|
|
static NSString* pvAXStringAttribute(AXUIElementRef element, CFStringRef attr) {
|
CFTypeRef valueRef = NULL;
|
AXError err = AXUIElementCopyAttributeValue(element, attr, &valueRef);
|
if (err != kAXErrorSuccess || !valueRef) return nil;
|
NSString* result = nil;
|
if (CFGetTypeID(valueRef) == CFStringGetTypeID()) {
|
result = [(__bridge NSString*)valueRef copy];
|
}
|
CFRelease(valueRef);
|
return [result autorelease];
|
}
|
|
static NSString* pvAXElementSummary(AXUIElementRef element) {
|
NSMutableArray<NSString*>* parts = [NSMutableArray array];
|
pid_t pid = 0;
|
if (AXUIElementGetPid(element, &pid) == kAXErrorSuccess && pid > 0) {
|
NSRunningApplication* app = [NSRunningApplication runningApplicationWithProcessIdentifier:pid];
|
NSString* name = [app localizedName];
|
if (name.length > 0) {
|
[parts addObject:[NSString stringWithFormat:@"app=%@", name]];
|
}
|
[parts addObject:[NSString stringWithFormat:@"pid=%d", pid]];
|
}
|
NSString* role = pvAXStringAttribute(element, kAXRoleAttribute);
|
if (role.length > 0) {
|
[parts addObject:[NSString stringWithFormat:@"role=%@", role]];
|
}
|
NSString* subrole = pvAXStringAttribute(element, kAXSubroleAttribute);
|
if (subrole.length > 0) {
|
[parts addObject:[NSString stringWithFormat:@"subrole=%@", subrole]];
|
}
|
if (parts.count == 0) return @"target=unknown";
|
return [parts componentsJoinedByString:@" "];
|
}
|
|
static BOOL pvAXAttributeSettable(AXUIElementRef element, CFStringRef attr, Boolean* settable) {
|
Boolean localSettable = false;
|
AXError err = AXUIElementIsAttributeSettable(element, attr, &localSettable);
|
if (settable) *settable = localSettable;
|
return err == kAXErrorSuccess;
|
}
|
|
static char* pvAXCopyResult(int ok, NSString* method, NSString* target, NSString* message) {
|
NSString* payload = [NSString stringWithFormat:@"%d\n%@\n%@\n%@",
|
ok,
|
method ?: @"ax_focused_element",
|
target ?: @"target=unknown",
|
message ?: @""];
|
return pvAXCopyError(payload);
|
}
|
|
static int pvAXTrusted(int prompt) {
|
if (prompt) {
|
NSDictionary* opts = @{(__bridge NSString*)kAXTrustedCheckOptionPrompt: @YES};
|
return AXIsProcessTrustedWithOptions((__bridge CFDictionaryRef)opts) ? 1 : 0;
|
}
|
return AXIsProcessTrusted() ? 1 : 0;
|
}
|
|
static AXUIElementRef pvAXCopyFrontmostFocusedElement(AXError* outErr) {
|
if (outErr) *outErr = kAXErrorFailure;
|
NSRunningApplication* app = [[NSWorkspace sharedWorkspace] frontmostApplication];
|
if (!app || app.processIdentifier <= 0) {
|
return NULL;
|
}
|
AXUIElementRef appElement = AXUIElementCreateApplication(app.processIdentifier);
|
if (!appElement) {
|
return NULL;
|
}
|
AXUIElementSetMessagingTimeout(appElement, 1.0);
|
AXUIElementRef focused = NULL;
|
AXError err = AXUIElementCopyAttributeValue(appElement, kAXFocusedUIElementAttribute, (CFTypeRef*)&focused);
|
CFRelease(appElement);
|
if (outErr) *outErr = err;
|
if (err != kAXErrorSuccess || !focused) {
|
return NULL;
|
}
|
return focused;
|
}
|
|
static AXUIElementRef pvAXCopyBestFocusedElement(AXError* outSystemErr, AXError* outFocusedAppErr, AXError* outFocusedAppElementErr, AXError* outFrontmostErr) {
|
if (outSystemErr) *outSystemErr = kAXErrorFailure;
|
if (outFocusedAppErr) *outFocusedAppErr = kAXErrorFailure;
|
if (outFocusedAppElementErr) *outFocusedAppElementErr = kAXErrorFailure;
|
if (outFrontmostErr) *outFrontmostErr = kAXErrorFailure;
|
|
AXUIElementRef system = AXUIElementCreateSystemWide();
|
if (!system) {
|
return NULL;
|
}
|
AXUIElementSetMessagingTimeout(system, 1.0);
|
|
AXUIElementRef focused = NULL;
|
AXError systemErr = AXUIElementCopyAttributeValue(system, kAXFocusedUIElementAttribute, (CFTypeRef*)&focused);
|
if (outSystemErr) *outSystemErr = systemErr;
|
if (systemErr == kAXErrorSuccess && focused) {
|
CFRelease(system);
|
return focused;
|
}
|
|
AXUIElementRef focusedApp = NULL;
|
AXError focusedAppErr = AXUIElementCopyAttributeValue(system, kAXFocusedApplicationAttribute, (CFTypeRef*)&focusedApp);
|
if (outFocusedAppErr) *outFocusedAppErr = focusedAppErr;
|
if (focusedAppErr == kAXErrorSuccess && focusedApp) {
|
AXUIElementSetMessagingTimeout(focusedApp, 1.0);
|
AXError focusedAppElementErr = AXUIElementCopyAttributeValue(focusedApp, kAXFocusedUIElementAttribute, (CFTypeRef*)&focused);
|
if (outFocusedAppElementErr) *outFocusedAppElementErr = focusedAppElementErr;
|
CFRelease(focusedApp);
|
if (focusedAppElementErr == kAXErrorSuccess && focused) {
|
CFRelease(system);
|
return focused;
|
}
|
}
|
CFRelease(system);
|
|
return pvAXCopyFrontmostFocusedElement(outFrontmostErr);
|
}
|
|
static char* pvAXDirectInsert(const char* text) {
|
if (!pvAXTrusted(0)) {
|
return pvAXCopyResult(0, @"ax_focused_element", nil, @"accessibility permission is not granted");
|
}
|
|
NSString* insert = [NSString stringWithUTF8String:text];
|
if (!insert) {
|
return pvAXCopyResult(0, @"ax_focused_element", nil, @"input text is not valid UTF-8");
|
}
|
|
AXUIElementRef focused = NULL;
|
AXError systemErr = kAXErrorFailure;
|
AXError focusedAppErr = kAXErrorFailure;
|
AXError focusedAppElementErr = kAXErrorFailure;
|
AXError frontmostErr = kAXErrorFailure;
|
for (int attempt = 0; attempt < 3 && !focused; attempt++) {
|
focused = pvAXCopyBestFocusedElement(&systemErr, &focusedAppErr, &focusedAppElementErr, &frontmostErr);
|
if (!focused && attempt < 2) {
|
usleep(50000);
|
}
|
}
|
if (!focused) {
|
return pvAXCopyResult(0, @"ax_focused_element", nil, [NSString stringWithFormat:@"focused element unavailable: system=%d focused_app=%d focused_app_element=%d frontmost=%d", systemErr, focusedAppErr, focusedAppElementErr, frontmostErr]);
|
}
|
|
NSString* target = pvAXElementSummary(focused);
|
|
CFTypeRef valueRef = NULL;
|
CFTypeRef rangeRef = NULL;
|
AXError valueErr = AXUIElementCopyAttributeValue(focused, kAXValueAttribute, &valueRef);
|
AXError rangeErr = AXUIElementCopyAttributeValue(focused, kAXSelectedTextRangeAttribute, &rangeRef);
|
if (valueErr != kAXErrorSuccess || rangeErr != kAXErrorSuccess || !valueRef || !rangeRef ||
|
CFGetTypeID(valueRef) != CFStringGetTypeID() || CFGetTypeID(rangeRef) != AXValueGetTypeID()) {
|
if (valueRef) CFRelease(valueRef);
|
if (rangeRef) CFRelease(rangeRef);
|
CFRelease(focused);
|
return pvAXCopyResult(0, @"ax_focused_element",
|
target,
|
[NSString stringWithFormat:@"focused text state is not readable; value=%d range=%d", valueErr, rangeErr]);
|
}
|
|
CFRange selectedRange;
|
if (!AXValueGetValue((AXValueRef)rangeRef, kAXValueCFRangeType, &selectedRange)) {
|
CFRelease(valueRef);
|
CFRelease(rangeRef);
|
CFRelease(focused);
|
return pvAXCopyResult(0, @"ax_value_replacement", target, @"focused element selected range is unreadable");
|
}
|
|
NSString* value = (__bridge NSString*)valueRef;
|
NSUInteger valueLength = [value length];
|
if (selectedRange.location < 0 || selectedRange.length < 0 ||
|
(NSUInteger)selectedRange.location > valueLength ||
|
(NSUInteger)(selectedRange.location + selectedRange.length) > valueLength) {
|
CFRelease(valueRef);
|
CFRelease(rangeRef);
|
CFRelease(focused);
|
return pvAXCopyResult(0, @"ax_value_replacement", target, @"focused element selected range is out of bounds");
|
}
|
|
Boolean valueSettable = false;
|
BOOL settableKnown = pvAXAttributeSettable(focused, kAXValueAttribute, &valueSettable);
|
if (settableKnown && !valueSettable) {
|
CFRelease(valueRef);
|
CFRelease(rangeRef);
|
CFRelease(focused);
|
return pvAXCopyResult(0,
|
@"ax_value_replacement",
|
target,
|
@"focused element value is not settable");
|
}
|
|
NSRange nsRange = NSMakeRange((NSUInteger)selectedRange.location, (NSUInteger)selectedRange.length);
|
NSString* updated = [value stringByReplacingCharactersInRange:nsRange withString:insert];
|
AXError setErr = AXUIElementSetAttributeValue(focused, kAXValueAttribute, (__bridge CFTypeRef)updated);
|
if (setErr == kAXErrorSuccess) {
|
CFRange newRange = CFRangeMake(selectedRange.location + [insert length], 0);
|
AXValueRef newRangeValue = AXValueCreate(kAXValueCFRangeType, &newRange);
|
if (newRangeValue) {
|
AXUIElementSetAttributeValue(focused, kAXSelectedTextRangeAttribute, newRangeValue);
|
CFRelease(newRangeValue);
|
}
|
}
|
|
CFTypeRef verifyRef = NULL;
|
AXError verifyErr = AXUIElementCopyAttributeValue(focused, kAXValueAttribute, &verifyRef);
|
BOOL verified = false;
|
if (verifyErr == kAXErrorSuccess && verifyRef && CFGetTypeID(verifyRef) == CFStringGetTypeID()) {
|
NSString* verifiedValue = (__bridge NSString*)verifyRef;
|
verified = [verifiedValue isEqualToString:updated];
|
}
|
if (verifyRef) CFRelease(verifyRef);
|
|
CFRelease(valueRef);
|
CFRelease(rangeRef);
|
CFRelease(focused);
|
if (setErr != kAXErrorSuccess) {
|
return pvAXCopyResult(0, @"ax_value_replacement", target, [NSString stringWithFormat:@"AX value replacement failed: %d", setErr]);
|
}
|
if (!verified) {
|
return pvAXCopyResult(0, @"ax_value_replacement", target, [NSString stringWithFormat:@"AX value replacement was not observable after write; verify=%d", verifyErr]);
|
}
|
return pvAXCopyResult(1, @"ax_value_replacement", target, @"focused element value changed after write");
|
}
|
|
static int pvSetClipboardText(const char* text) {
|
NSPasteboard* pb = [NSPasteboard generalPasteboard];
|
if (!pb) return 0;
|
NSString* str = [NSString stringWithUTF8String:text];
|
if (!str) return 0;
|
[pb clearContents];
|
NSArray<NSPasteboardType>* types = @[NSPasteboardTypeString];
|
[pb declareTypes:types owner:nil];
|
BOOL wrote = [pb setString:str forType:NSPasteboardTypeString];
|
NSString* verified = [pb stringForType:NSPasteboardTypeString];
|
return wrote && verified && [verified isEqualToString:str] ? 1 : 0;
|
}
|
|
static int pvClearClipboard(void) {
|
NSPasteboard* pb = [NSPasteboard generalPasteboard];
|
if (!pb) return 0;
|
[pb clearContents];
|
return [pb stringForType:NSPasteboardTypeString] == nil ? 1 : 0;
|
}
|
|
static char* pvGetClipboardText(void) {
|
NSPasteboard* pb = [NSPasteboard generalPasteboard];
|
NSString* str = [pb stringForType:NSPasteboardTypeString];
|
if (!str) return NULL;
|
const char* utf8 = [str UTF8String];
|
if (!utf8) return NULL;
|
return strdup(utf8);
|
}
|
|
static char* pvCopyFrontmostAppIdentity(void) {
|
NSRunningApplication* app = [[NSWorkspace sharedWorkspace] frontmostApplication];
|
if (!app || app.processIdentifier <= 0) return NULL;
|
NSString* bundleID = [app bundleIdentifier] ?: @"";
|
NSString* identity = [NSString stringWithFormat:@"bundle=%@ pid=%d", bundleID, app.processIdentifier];
|
const char* utf8 = [identity UTF8String];
|
if (!utf8) return NULL;
|
return strdup(utf8);
|
}
|
|
static int pvPostCommandVIfFrontmostUnchanged(const char* expectedIdentity) {
|
if (!expectedIdentity || strlen(expectedIdentity) == 0) return -1;
|
char* currentIdentity = pvCopyFrontmostAppIdentity();
|
if (!currentIdentity) return -1;
|
int same = strcmp(currentIdentity, expectedIdentity) == 0;
|
free(currentIdentity);
|
if (!same) return 0;
|
|
CGEventSourceRef source = CGEventSourceCreate(kCGEventSourceStateCombinedSessionState);
|
if (!source) return -2;
|
CGEventRef keyDown = CGEventCreateKeyboardEvent(source, (CGKeyCode)9, true);
|
CGEventRef keyUp = CGEventCreateKeyboardEvent(source, (CGKeyCode)9, false);
|
if (!keyDown || !keyUp) {
|
if (keyDown) CFRelease(keyDown);
|
if (keyUp) CFRelease(keyUp);
|
CFRelease(source);
|
return -2;
|
}
|
CGEventSetFlags(keyDown, kCGEventFlagMaskCommand);
|
CGEventSetFlags(keyUp, kCGEventFlagMaskCommand);
|
CGEventPost(kCGHIDEventTap, keyDown); // AX10DT_EXPERIMENT_ALLOW_CGEVENTPOST: one-shot Cmd+V only when explicitly enabled by config.
|
CGEventPost(kCGHIDEventTap, keyUp); // AX10DT_EXPERIMENT_ALLOW_CGEVENTPOST: one-shot Cmd+V only when explicitly enabled by config.
|
CFRelease(keyDown);
|
CFRelease(keyUp);
|
CFRelease(source);
|
return 1;
|
}
|
*/
|
import "C"
|
|
import (
|
"strings"
|
"unsafe"
|
)
|
|
type darwinDriver struct {
|
clipboard clipboardState
|
}
|
|
var (
|
readClipboardSnapshot = currentClipboardSnapshot
|
writeClipboardText = writeClipboardTextDarwin
|
clearClipboardText = clearClipboardTextDarwin
|
)
|
|
func newPlatformDriver() Driver {
|
return &darwinDriver{}
|
}
|
|
func (d *darwinDriver) AccessibilityTrusted(prompt bool) bool {
|
if prompt {
|
return C.pvAXTrusted(1) != 0
|
}
|
return C.pvAXTrusted(0) != 0
|
}
|
|
func (d *darwinDriver) DirectInsert(text string) DirectInsertResult {
|
if text == "" {
|
return DirectInsertResult{OK: false, Method: "ax_focused_element", Message: "text is empty"}
|
}
|
cText := C.CString(text)
|
defer C.free(unsafe.Pointer(cText))
|
cResult := C.pvAXDirectInsert(cText)
|
if cResult == nil {
|
return DirectInsertResult{
|
OK: false,
|
Inserted: false,
|
NeedsPermission: !d.AccessibilityTrusted(false),
|
Method: "ax_focused_element",
|
Message: "AX direct insert returned no result",
|
}
|
}
|
defer C.free(unsafe.Pointer(cResult))
|
ok, method, target, msg := parseAXDirectInsertPayload(C.GoString(cResult))
|
if !ok {
|
return DirectInsertResult{
|
OK: false,
|
Inserted: false,
|
NeedsPermission: !d.AccessibilityTrusted(false),
|
Method: method,
|
Message: msg,
|
Target: target,
|
}
|
}
|
return DirectInsertResult{
|
OK: true,
|
Inserted: true,
|
Method: method,
|
Message: msg,
|
Target: target,
|
}
|
}
|
|
func parseAXDirectInsertPayload(payload string) (bool, string, string, string) {
|
parts := strings.SplitN(payload, "\n", 4)
|
if len(parts) != 4 {
|
return false, "ax_focused_element", "", payload
|
}
|
return parts[0] == "1", parts[1], parts[2], parts[3]
|
}
|
|
func (d *darwinDriver) CopyTextToClipboard(text string) ClipboardResult {
|
if text == "" {
|
return ClipboardResult{OK: false, Message: "text is empty"}
|
}
|
if !writeClipboardText(text) {
|
return ClipboardResult{
|
OK: false,
|
Message: "clipboard could not be written",
|
}
|
}
|
return ClipboardResult{
|
OK: true,
|
Prepared: true,
|
Message: "clipboard updated; user must paste manually",
|
}
|
}
|
|
func (d *darwinDriver) FrontmostAppIdentity() FrontmostAppIdentity {
|
cIdentity := C.pvCopyFrontmostAppIdentity()
|
if cIdentity == nil {
|
return FrontmostAppIdentity{OK: false, Message: "frontmost app identity is unavailable"}
|
}
|
defer C.free(unsafe.Pointer(cIdentity))
|
identity := C.GoString(cIdentity)
|
if strings.TrimSpace(identity) == "" {
|
return FrontmostAppIdentity{OK: false, Message: "frontmost app identity is empty"}
|
}
|
return FrontmostAppIdentity{OK: true, Identity: identity}
|
}
|
|
func (d *darwinDriver) AutoPasteClipboardIfFrontmostUnchanged(expectedIdentity string) AutoPasteResult {
|
if strings.TrimSpace(expectedIdentity) == "" {
|
return AutoPasteResult{OK: false, Message: "frontmost app identity is unavailable"}
|
}
|
cExpected := C.CString(expectedIdentity)
|
defer C.free(unsafe.Pointer(cExpected))
|
switch C.pvPostCommandVIfFrontmostUnchanged(cExpected) {
|
case 1:
|
return AutoPasteResult{OK: true, Pasted: true, FrontmostUnchanged: true, Message: "automatic paste event sent"}
|
case 0:
|
return AutoPasteResult{OK: false, Pasted: false, FrontmostUnchanged: false, Message: "frontmost app changed before automatic paste"}
|
default:
|
return AutoPasteResult{OK: false, Pasted: false, FrontmostUnchanged: false, Message: "automatic paste event could not be sent"}
|
}
|
}
|
|
func (d *darwinDriver) PrepareClipboardFallback(text string) ClipboardResult {
|
if text == "" {
|
return ClipboardResult{OK: false, Message: "text is empty"}
|
}
|
restore := readClipboardSnapshot()
|
if !writeClipboardText(text) {
|
return ClipboardResult{
|
OK: false,
|
Prepared: false,
|
Message: "clipboard fallback could not be written",
|
}
|
}
|
token := d.clipboard.remember(text, restore)
|
return ClipboardResult{
|
OK: true,
|
Prepared: true,
|
Token: token,
|
Message: "clipboard fallback prepared; user must paste manually",
|
}
|
}
|
|
func (d *darwinDriver) RestoreClipboardFallback(token string) ClipboardResult {
|
entry, ok := d.clipboard.take(token)
|
if !ok {
|
return ClipboardResult{OK: false, Message: "unknown or already restored fallback token"}
|
}
|
current := readClipboardSnapshot()
|
if !shouldRestoreClipboard(current, entry.fallbackText) {
|
return ClipboardResult{
|
OK: false,
|
Restored: false,
|
Message: "clipboard changed after fallback preparation; restore skipped",
|
}
|
}
|
if entry.restore.hasText {
|
if !writeClipboardText(entry.restore.text) {
|
return ClipboardResult{OK: false, Restored: false, Message: "clipboard restore failed"}
|
}
|
return ClipboardResult{OK: true, Restored: true, Message: "clipboard restored"}
|
}
|
if !clearClipboardText() {
|
return ClipboardResult{OK: false, Restored: false, Message: "clipboard restore failed"}
|
}
|
return ClipboardResult{OK: true, Restored: true, Message: "clipboard restored"}
|
}
|
|
func writeClipboardTextDarwin(text string) bool {
|
cText := C.CString(text)
|
defer C.free(unsafe.Pointer(cText))
|
return C.pvSetClipboardText(cText) != 0
|
}
|
|
func clearClipboardTextDarwin() bool {
|
return C.pvClearClipboard() != 0
|
}
|
|
func currentClipboardSnapshot() clipboardSnapshot {
|
cText := C.pvGetClipboardText()
|
if cText == nil {
|
return clipboardSnapshot{}
|
}
|
defer C.free(unsafe.Pointer(cText))
|
return clipboardSnapshot{text: C.GoString(cText), hasText: true}
|
}
|
