//go:build darwin && appstore
|
|
package textoutput
|
|
import (
|
"strings"
|
"unicode/utf8"
|
"voicesnap/internal/axinput"
|
"voicesnap/internal/logger"
|
)
|
|
func newPlatformRouter(paster Paster) *Router {
|
return &Router{
|
paster: paster,
|
driver: axinput.NewDriver(),
|
}
|
}
|
|
func (r *Router) Output(text string, keepClipboard bool) Result {
|
return r.OutputWithOptions(text, OutputOptions{KeepClipboard: keepClipboard})
|
}
|
|
func (r *Router) OutputWithOptions(text string, options OutputOptions) Result {
|
if text == "" {
|
return r.remember(Result{OK: false, Method: "ax_direct_insert", Message: "text is empty"})
|
}
|
if r.driver == nil {
|
return r.remember(Result{
|
OK: false,
|
Text: text,
|
Method: "ax_direct_insert",
|
Message: "AX driver is unavailable",
|
FallbackAvailable: false,
|
})
|
}
|
direct := r.driver.DirectInsert(text)
|
if direct.OK && direct.Inserted {
|
return r.remember(Result{
|
OK: true,
|
Text: text,
|
Method: direct.Method,
|
Message: direct.Message,
|
Target: direct.Target,
|
DirectInserted: true,
|
})
|
}
|
fallbackAvailable := clipboardFallbackSafeForTarget(Result{Target: direct.Target})
|
category, codes := directInsertDiagnostic(direct)
|
logger.Info(
|
"Text output direct insert route status=driver_result ok=%t inserted=%t needs_permission=%t category=%s codes=%s text_runes=%d",
|
direct.OK,
|
direct.Inserted,
|
direct.NeedsPermission,
|
category,
|
codes,
|
utf8.RuneCountInString(text),
|
)
|
if fallbackAvailable && options.AutoPasteExperiment {
|
autoPaste := r.autoPasteClipboardExperiment(text, direct, options)
|
if autoPaste.OK && autoPaste.Pasted {
|
return r.remember(Result{
|
OK: true,
|
Text: text,
|
Method: "clipboard_auto_paste_experiment",
|
Message: "clipboard fallback auto-paste experiment sent one paste event",
|
Target: direct.Target,
|
DirectInserted: false,
|
})
|
}
|
return r.remember(Result{
|
OK: false,
|
Text: text,
|
Method: direct.Method,
|
Message: direct.Message,
|
Target: direct.Target,
|
NeedsPermission: direct.NeedsPermission,
|
DirectInserted: false,
|
FallbackAvailable: fallbackAvailable,
|
})
|
}
|
if fallbackAvailable && options.KeepClipboard {
|
clipboard := r.driver.CopyTextToClipboard(text)
|
logger.Info(
|
"Text output copy-to-clipboard route status=driver_result ok=%t prepared=%t text_runes=%d",
|
clipboard.OK,
|
clipboard.Prepared,
|
utf8.RuneCountInString(text),
|
)
|
}
|
return r.remember(Result{
|
OK: false,
|
Text: text,
|
Method: direct.Method,
|
Message: direct.Message,
|
Target: direct.Target,
|
NeedsPermission: direct.NeedsPermission,
|
DirectInserted: false,
|
FallbackAvailable: fallbackAvailable,
|
})
|
}
|
|
func (r *Router) autoPasteClipboardExperiment(text string, direct axinput.DirectInsertResult, options OutputOptions) axinput.AutoPasteResult {
|
textRunes := utf8.RuneCountInString(text)
|
guard := options.AutoPasteGuard
|
if !guard.OK || strings.TrimSpace(guard.Identity) == "" {
|
logger.Info("Text output auto-paste experiment status=blocked_guard_unavailable text_runes=%d", textRunes)
|
return axinput.AutoPasteResult{OK: false, Message: "frontmost guard is unavailable"}
|
}
|
currentIdentity := r.driver.FrontmostAppIdentity()
|
if !currentIdentity.OK || strings.TrimSpace(currentIdentity.Identity) == "" {
|
logger.Info("Text output auto-paste experiment status=blocked_current_identity_unavailable text_runes=%d", textRunes)
|
return axinput.AutoPasteResult{OK: false, Message: "frontmost identity is unavailable before clipboard write"}
|
}
|
if currentIdentity.Identity != guard.Identity {
|
logger.Info("Text output auto-paste experiment status=blocked_frontmost_changed_before_clipboard text_runes=%d", textRunes)
|
return axinput.AutoPasteResult{OK: false, Message: "frontmost app changed before clipboard write"}
|
}
|
if !autoPasteSafeForIdentity(currentIdentity.Identity) || !clipboardFallbackSafeForTarget(Result{Target: direct.Target}) {
|
logger.Info(
|
"Text output auto-paste experiment status=blocked_non_writable text_runes=%d identity_present=%t target_known=%t",
|
textRunes,
|
currentIdentity.Identity != "",
|
strings.TrimSpace(direct.Target) != "" && strings.TrimSpace(direct.Target) != "target=unknown",
|
)
|
return axinput.AutoPasteResult{OK: false, Message: "automatic paste is disabled for this target"}
|
}
|
var token string
|
if options.KeepClipboard {
|
clipboard := r.driver.CopyTextToClipboard(text)
|
logger.Info(
|
"Text output copy-to-clipboard route status=driver_result ok=%t prepared=%t text_runes=%d",
|
clipboard.OK,
|
clipboard.Prepared,
|
textRunes,
|
)
|
if !clipboard.OK || !clipboard.Prepared {
|
logger.Info(
|
"Text output auto-paste experiment status=blocked_clipboard_unprepared text_runes=%d clipboard_ok=%t clipboard_prepared=%t",
|
textRunes,
|
clipboard.OK,
|
clipboard.Prepared,
|
)
|
return axinput.AutoPasteResult{OK: false, Message: "clipboard is not prepared"}
|
}
|
} else {
|
clipboard := r.driver.PrepareClipboardFallback(text)
|
logger.Info(
|
"Text output auto-paste experiment clipboard prepare status=driver_result ok=%t prepared=%t token_present=%t text_runes=%d",
|
clipboard.OK,
|
clipboard.Prepared,
|
clipboard.Token != "",
|
textRunes,
|
)
|
if !clipboard.OK || !clipboard.Prepared || clipboard.Token == "" {
|
logger.Info(
|
"Text output auto-paste experiment status=blocked_clipboard_token_unavailable text_runes=%d clipboard_ok=%t clipboard_prepared=%t token_present=%t",
|
textRunes,
|
clipboard.OK,
|
clipboard.Prepared,
|
clipboard.Token != "",
|
)
|
return axinput.AutoPasteResult{OK: false, Message: "clipboard restore token is unavailable"}
|
}
|
token = clipboard.Token
|
}
|
result := r.driver.AutoPasteClipboardIfFrontmostUnchanged(guard.Identity)
|
logger.Info(
|
"Text output auto-paste experiment status=driver_result ok=%t pasted=%t frontmost_unchanged=%t text_runes=%d",
|
result.OK,
|
result.Pasted,
|
result.FrontmostUnchanged,
|
textRunes,
|
)
|
if token != "" {
|
restore := r.driver.RestoreClipboardFallback(token)
|
logger.Info(
|
"Text output auto-paste experiment clipboard restore status=driver_result ok=%t restored=%t token_present=%t text_runes=%d",
|
restore.OK,
|
restore.Restored,
|
token != "",
|
textRunes,
|
)
|
if result.OK && result.Pasted && !restore.OK && !restore.Restored {
|
return axinput.AutoPasteResult{OK: false, Pasted: result.Pasted, FrontmostUnchanged: result.FrontmostUnchanged, Message: "clipboard restore did not complete"}
|
}
|
}
|
return result
|
}
|
|
func directInsertDiagnostic(result axinput.DirectInsertResult) (string, string) {
|
if result.NeedsPermission {
|
return "accessibility_permission", "none"
|
}
|
message := strings.ToLower(result.Message)
|
switch {
|
case strings.Contains(message, "focused element unavailable"):
|
return "focused_element_unavailable", extractAXCodeSummary(result.Message)
|
case strings.Contains(message, "text state is not readable"):
|
return "focused_text_state_unreadable", extractAXCodeSummary(result.Message)
|
case strings.Contains(message, "value is not settable"):
|
return "focused_value_not_settable", "none"
|
case strings.Contains(message, "selected range is unreadable"):
|
return "selected_range_unreadable", "none"
|
case strings.Contains(message, "selected range is out of bounds"):
|
return "selected_range_out_of_bounds", "none"
|
case strings.Contains(message, "replacement failed"):
|
return "ax_value_replacement_failed", extractAXCodeSummary(result.Message)
|
case strings.Contains(message, "not observable after write"):
|
return "ax_value_verify_failed", extractAXCodeSummary(result.Message)
|
default:
|
return "direct_insert_failed", extractAXCodeSummary(result.Message)
|
}
|
}
|
|
func extractAXCodeSummary(message string) string {
|
allowed := map[string]bool{
|
"frontmost": true,
|
"focused_app": true,
|
"focused_app_element": true,
|
"range": true,
|
"system": true,
|
"value": true,
|
"verify": true,
|
}
|
parts := strings.FieldsFunc(message, func(r rune) bool {
|
return r == ' ' || r == ',' || r == ';' || r == '\n' || r == '\t'
|
})
|
codes := make([]string, 0, len(parts))
|
for _, part := range parts {
|
key, value, ok := strings.Cut(strings.Trim(part, ".:"), "=")
|
if !ok || !allowed[key] || !isSignedDecimal(value) {
|
continue
|
}
|
codes = append(codes, key+"="+value)
|
}
|
if len(codes) == 0 {
|
return "none"
|
}
|
return strings.Join(codes, " ")
|
}
|
|
func isSignedDecimal(value string) bool {
|
if value == "" {
|
return false
|
}
|
if value[0] == '-' || value[0] == '+' {
|
value = value[1:]
|
}
|
if value == "" {
|
return false
|
}
|
for _, r := range value {
|
if r < '0' || r > '9' {
|
return false
|
}
|
}
|
return true
|
}
|
