@mseep/clawdcursor 1.5.5

package/scripts/mac/get-screen-context.jxa

@@ -0,0 +1,197 @@
+#!/usr/bin/env osascript -l JavaScript
+
+/**
+ * get-screen-context.jxa
+ *
+ * Combined script: gets windows list + focused window UI tree in ONE osascript spawn.
+ * macOS equivalent of get-screen-context.ps1.
+ *
+ * Output shape (matches PS1 exactly so accessibility.ts needs no changes):
+ *   { windows: WindowInfo[], uiTree: UINode | null }
+ *
+ * Parameters (read from argv):
+ *   -FocusedProcessId <number>  — if provided, include UI tree for that process
+ *   -MaxDepth <number>          — max UI tree depth (default 2)
+ *
+ * Output: script result (last expression) goes to stdout for Node.js execFile.
+ *
+ * Usage: osascript -l JavaScript get-screen-context.jxa -FocusedProcessId 1234 -MaxDepth 2
+ */
+
+ObjC.import('stdlib');
+
+// ─── Argument parsing ────────────────────────────────────────────────────────
+
+function parseArgs() {
+    var args = ObjC.unwrap($.NSProcessInfo.processInfo.arguments);
+    var result = { focusedProcessId: 0, maxDepth: 2 };
+    for (var i = 0; i < args.length; i++) {
+        var arg = ObjC.unwrap(args[i]);
+        if (arg === '-FocusedProcessId' && i + 1 < args.length) {
+            result.focusedProcessId = parseInt(ObjC.unwrap(args[i + 1]), 10) || 0;
+        } else if (arg === '-MaxDepth' && i + 1 < args.length) {
+            result.maxDepth = parseInt(ObjC.unwrap(args[i + 1]), 10) || 2;
+        }
+    }
+    return result;
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function safeGet(obj, prop, def) {
+    try { var v = obj[prop](); return (v !== undefined && v !== null) ? v : def; }
+    catch (e) { return def; }
+}
+
+function safeProp(el, prop, def) {
+    try { return el[prop] ? el[prop]() : def; }
+    catch (e) { return def; }
+}
+
+function getBounds(el) {
+    try {
+        var pos = el.position();
+        var sz  = el.size();
+        return { x: pos[0], y: pos[1], width: sz[0], height: sz[1] };
+    } catch (e) {
+        return { x: 0, y: 0, width: 0, height: 0 };
+    }
+}
+
+// ─── Part 1: windows list (same logic as get-windows.jxa) ────────────────────
+
+function getWindows(SystemEvents) {
+    var processes = SystemEvents.processes.where({ backgroundOnly: false });
+    var results = [];
+
+    for (var i = 0; i < processes.length; i++) {
+        try {
+            var proc       = processes[i];
+            var procName   = safeGet(proc, 'name', 'unknown');
+            var procId     = safeGet(proc, 'unixId', 0);
+            var windows    = proc.windows;
+
+            for (var j = 0; j < windows.length; j++) {
+                try {
+                    var win   = windows[j];
+                    var title = safeProp(win, 'name', '');
+                    if (!title || title.trim().length === 0) continue;
+
+                    var isMinimized = false;
+                    try { isMinimized = win.miniaturized(); } catch (e) {}
+
+                    results.push({
+                        handle:      procId,
+                        title:       title,
+                        processName: procName,
+                        processId:   procId,
+                        bounds:      getBounds(win),
+                        isMinimized: isMinimized
+                    });
+                } catch (e) {}
+            }
+        } catch (e) {}
+    }
+
+    return results;
+}
+
+// ─── Part 2: UI tree for focused process ─────────────────────────────────────
+
+// Interactive macOS roles worth sending to the LLM
+var INTERACTIVE_ROLES = {
+    'AXButton': true, 'AXTextField': true, 'AXTextArea': true,
+    'AXComboBox': true, 'AXCheckBox': true, 'AXRadioButton': true,
+    'AXLink': true, 'AXMenuItem': true, 'AXMenu': true,
+    'AXTab': true, 'AXTabGroup': true, 'AXList': true,
+    'AXOutline': true, 'AXSlider': true, 'AXScrollBar': true,
+    'AXToolbar': true, 'AXWebArea': true, 'AXStaticText': true,
+    'AXGroup': true
+};
+
+function buildUINode(element, maxDepth, depth) {
+    if (depth > maxDepth) return null;
+
+    var name    = '';
+    var role    = '';
+    var value   = '';
+    var subrole = '';
+
+    try { name    = element.name()    || ''; } catch (e) {}
+    try { role    = element.role()    || ''; } catch (e) {}
+    try { value   = element.value()   || ''; } catch (e) {}
+    // Secureness lives in the AX SUBROLE: a password field reports
+    // role=AXTextField, subrole=AXSecureTextField. Surface it so the snapshot
+    // builder can redact the value (audit 2026-06-11, M2) — without this the
+    // cleartext password reached the LLM prompt + fingerprint on macOS.
+    try { subrole = element.subrole() || ''; } catch (e) {}
+
+    var isInteractive = !!INTERACTIVE_ROLES[role];
+    var hasName       = name.trim().length > 0;
+    var isSecure      = (subrole === 'AXSecureTextField');
+    if (isSecure) { value = ''; }   // never emit the secret, even pre-redaction
+
+    // Build children first so we can decide whether to include this node
+    var children = [];
+    if (depth < maxDepth) {
+        try {
+            var kids = element.uiElements();
+            for (var i = 0; i < kids.length; i++) {
+                try {
+                    var child = buildUINode(kids[i], maxDepth, depth + 1);
+                    if (child) children.push(child);
+                } catch (e) {}
+            }
+        } catch (e) {}
+    }
+
+    // Skip uninteresting, unnamed leaf nodes (mirrors PS1 behaviour)
+    if (!isInteractive && !hasName && children.length === 0) return null;
+
+    return {
+        name:         name,
+        automationId: '',            // macOS has no AutomationId concept
+        controlType:  role,
+        subrole:      subrole || undefined,
+        secure:       isSecure || undefined,
+        bounds:       getBounds(element),
+        value:        value || undefined,
+        children:     children.length > 0 ? children : undefined
+    };
+}
+
+function getUITree(SystemEvents, focusedProcessId, maxDepth) {
+    if (!focusedProcessId) return null;
+
+    try {
+        var procs = SystemEvents.processes.where({ unixId: focusedProcessId });
+        if (procs.length === 0) return null;
+
+        var proc    = procs[0];
+        var windows = proc.windows;
+        if (windows.length === 0) return null;
+
+        // Use the first (frontmost) window
+        return buildUINode(windows[0], maxDepth, 0);
+    } catch (e) {
+        return null;
+    }
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+var output;
+try {
+    var params       = parseArgs();
+    var SystemEvents = Application('System Events');
+    SystemEvents.includeStandardAdditions = true;
+
+    var windows = getWindows(SystemEvents);
+    var uiTree  = getUITree(SystemEvents, params.focusedProcessId, params.maxDepth);
+
+    output = JSON.stringify({ windows: windows, uiTree: uiTree });
+} catch (error) {
+    output = JSON.stringify({ error: error.toString() });
+    $.exit(1);
+}
+output;

package/scripts/mac/get-ui-tree.sh

@@ -0,0 +1,141 @@
+#!/usr/bin/env bash
+# get-ui-tree.sh — Get the accessibility tree of the frontmost app on macOS
+#
+# Uses JXA (JavaScript for Automation) + System Events to walk the UI element
+# hierarchy of the frontmost application.
+#
+# Returns JSON with name, role, subrole, description, position, size for each element.
+#
+# Parameters:
+#   -ProcessId <number>  Optional. If specified, get tree for this process.
+#                        Otherwise uses the frontmost app.
+#   -MaxDepth <number>   Optional. Maximum traversal depth (default 6).
+#
+# Usage:
+#   chmod +x scripts/mac/get-ui-tree.sh
+#   ./scripts/mac/get-ui-tree.sh
+#   ./scripts/mac/get-ui-tree.sh -ProcessId 1234
+
+set -euo pipefail
+
+# Parse arguments
+PROCESS_ID=""
+MAX_DEPTH="6"
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -ProcessId) PROCESS_ID="$2"; shift 2 ;;
+    -MaxDepth)  MAX_DEPTH="$2"; shift 2 ;;
+    *)          shift ;;
+  esac
+done
+
+# Run JXA inline to walk the accessibility tree
+osascript -l JavaScript - "$PROCESS_ID" "$MAX_DEPTH" <<'ENDSCRIPT'
+ObjC.import('stdlib');
+
+var args = ObjC.unwrap($.NSProcessInfo.processInfo.arguments);
+// Arguments: [osascript, -, processId, maxDepth]
+var targetPid = args.length > 2 ? parseInt(ObjC.unwrap(args[2]), 10) : 0;
+var maxDepth = args.length > 3 ? parseInt(ObjC.unwrap(args[3]), 10) : 6;
+
+function safeGet(obj, property, defaultValue) {
+    try {
+        var val = obj[property]();
+        return val !== undefined && val !== null ? val : defaultValue;
+    } catch (e) {
+        return defaultValue;
+    }
+}
+
+function walkTree(element, depth) {
+    if (depth > maxDepth) return null;
+
+    var node = {};
+
+    try { node.name = element.name() || ''; } catch (e) { node.name = ''; }
+    try { node.role = element.role() || ''; } catch (e) { node.role = ''; }
+    try { node.subrole = element.subrole() || ''; } catch (e) { node.subrole = ''; }
+    try { node.description = element.description() || ''; } catch (e) { node.description = ''; }
+    try { node.value = String(element.value() || ''); } catch (e) { node.value = ''; }
+    try { node.enabled = element.enabled(); } catch (e) { node.enabled = true; }
+
+    // Position and size
+    try {
+        var pos = element.position();
+        var sz = element.size();
+        node.position = { x: pos[0] || 0, y: pos[1] || 0 };
+        node.size = { width: sz[0] || 0, height: sz[1] || 0 };
+    } catch (e) {
+        node.position = { x: 0, y: 0 };
+        node.size = { width: 0, height: 0 };
+    }
+
+    // Recurse into children
+    var children = [];
+    try {
+        var uiElements = element.uiElements();
+        for (var i = 0; i < uiElements.length && i < 50; i++) {
+            var child = walkTree(uiElements[i], depth + 1);
+            if (child) children.push(child);
+        }
+    } catch (e) {
+        // No children accessible
+    }
+
+    if (children.length > 0) {
+        node.children = children;
+    }
+
+    return node;
+}
+
+try {
+    var SystemEvents = Application('System Events');
+    SystemEvents.includeStandardAdditions = true;
+
+    var targetProcess;
+    if (targetPid && targetPid > 0) {
+        var procs = SystemEvents.processes.where({ unixId: targetPid });
+        if (procs.length === 0) {
+            console.log(JSON.stringify({ error: 'No process found with ID ' + targetPid }));
+            $.exit(1);
+        }
+        targetProcess = procs[0];
+    } else {
+        // Use frontmost process
+        var frontProcs = SystemEvents.processes.where({ frontmost: true });
+        if (frontProcs.length === 0) {
+            console.log(JSON.stringify({ error: 'No frontmost process found' }));
+            $.exit(1);
+        }
+        targetProcess = frontProcs[0];
+    }
+
+    var processName = safeGet(targetProcess, 'name', 'unknown');
+    var processId = safeGet(targetProcess, 'unixId', 0);
+
+    var tree = {
+        processName: processName,
+        processId: processId,
+        windows: []
+    };
+
+    var windows = targetProcess.windows;
+    for (var w = 0; w < windows.length && w < 5; w++) {
+        try {
+            var winNode = walkTree(windows[w], 0);
+            if (winNode) {
+                tree.windows.push(winNode);
+            }
+        } catch (e) {
+            // Window not accessible
+        }
+    }
+
+    console.log(JSON.stringify(tree, null, 0));
+} catch (error) {
+    console.log(JSON.stringify({ error: error.toString() }));
+    $.exit(1);
+}
+ENDSCRIPT

package/scripts/mac/get-windows.jxa

@@ -0,0 +1,117 @@
+#!/usr/bin/env osascript -l JavaScript
+
+/**
+ * get-windows.jxa
+ * 
+ * Lists all visible top-level windows with their properties.
+ * Returns a JSON array of all visible windows including:
+ * - title: Window title (name)
+ * - processName: Name of the owning application
+ * - processId: Unix process ID
+ * - bounds: {x, y, width, height} window position and size
+ * - isMinimized: Boolean indicating if window is minimized
+ * 
+ * Usage: osascript -l JavaScript get-windows.jxa
+ */
+
+// Utility function to safely get property values
+function safeGet(obj, property, defaultValue) {
+    try {
+        var val = obj[property]();
+        return val !== undefined && val !== null ? val : defaultValue;
+    } catch (e) {
+        return defaultValue;
+    }
+}
+
+// Utility function to safely get UI element properties
+function safeElementProp(element, propName, defaultValue) {
+    try {
+        if (element[propName]) {
+            return element[propName]();
+        }
+        return defaultValue;
+    } catch (e) {
+        return defaultValue;
+    }
+}
+
+// run(argv) is the JXA entry point — osascript calls it and its return value becomes stdout.
+function run(argv) {
+    try {
+        // Get System Events application
+        var SystemEvents = Application('System Events');
+        SystemEvents.includeStandardAdditions = true;
+        
+        // Get all processes with UI
+        var processes = SystemEvents.processes.where({ backgroundOnly: false });
+        var results = [];
+        
+        for (var i = 0; i < processes.length; i++) {
+            try {
+                var process = processes[i];
+                var processName = safeGet(process, 'name', 'unknown');
+                var processId = safeGet(process, 'unixId', 0);
+                
+                // Get all windows for this process
+                var windows = process.windows;
+                
+                for (var j = 0; j < windows.length; j++) {
+                    try {
+                        var win = windows[j];
+                        var title = safeElementProp(win, 'name', '');
+                        
+                        // Skip windows with no name (invisible/system windows)
+                        if (!title || title.trim().length === 0) {
+                            continue;
+                        }
+                        
+                        // Get window bounds
+                        var bounds = { x: 0, y: 0, width: 0, height: 0 };
+                        try {
+                            var position = win.position();
+                            var size = win.size();
+                            bounds = {
+                                x: position[0],
+                                y: position[1],
+                                width: size[0],
+                                height: size[1]
+                            };
+                        } catch (e) {
+                            // Bounds not available
+                        }
+                        
+                        // Check if minimized - macOS uses "miniaturized"
+                        var isMinimized = false;
+                        try {
+                            isMinimized = win.miniaturized();
+                        } catch (e) {
+                            // Property not available, assume not minimized
+                        }
+                        
+                        // macOS doesn't have window handles like Windows,
+                        // but we can use a combination of processId and index
+                        results.push({
+                            title: title,
+                            processName: processName,
+                            processId: processId,
+                            bounds: bounds,
+                            isMinimized: isMinimized
+                        });
+                    } catch (e) {
+                        // Skip windows that throw on property access
+                    }
+                }
+            } catch (e) {
+                // Skip processes that throw
+            }
+        }
+        
+        // Return JSON — osascript captures the return value as stdout
+        return JSON.stringify(results);
+        
+    } catch (error) {
+        // Return error as JSON
+        return JSON.stringify({ error: error.toString() });
+    }
+}

package/scripts/mac/interact-element.sh

@@ -0,0 +1,235 @@
+#!/usr/bin/env bash
+# interact-element.sh — Click, type, set value, focus elements on macOS
+#
+# Uses JXA (JavaScript for Automation) + System Events to interact with
+# native macOS UI elements via the Accessibility API.
+#
+# Outputs JSON matching the Windows invoke-element.ps1 / interact-element.ps1 format.
+#
+# Parameters:
+#   -Name <string>           Match elements by name (contains, case-insensitive)
+#   -AutomationId <string>   Match by description/identifier
+#   -ControlType <string>    Filter by control type (Button, Edit, etc.)
+#   -ProcessId <number>      Required. Process ID of the target application
+#   -Action <string>         Required. Action: click, set-value, get-value, focus,
+#                            toggle, expand, collapse, select, sendkeys
+#   -Value <string>          Value for set-value/sendkeys actions
+#
+# Usage:
+#   chmod +x scripts/mac/interact-element.sh
+#   ./scripts/mac/interact-element.sh -Name "Save" -Action click -ProcessId 1234
+#   ./scripts/mac/interact-element.sh -Name "Search" -Action set-value -Value "hello" -ProcessId 1234
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Parse arguments
+NAME=""
+AUTOMATION_ID=""
+CONTROL_TYPE=""
+PROCESS_ID=""
+ACTION=""
+VALUE=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -Name)         NAME="$2"; shift 2 ;;
+    -AutomationId) AUTOMATION_ID="$2"; shift 2 ;;
+    -ControlType)  CONTROL_TYPE="$2"; shift 2 ;;
+    -ProcessId)    PROCESS_ID="$2"; shift 2 ;;
+    -Action)       ACTION="$2"; shift 2 ;;
+    -Value)        VALUE="$2"; shift 2 ;;
+    *)             shift ;;
+  esac
+done
+
+# Validate required parameters
+if [[ -z "$ACTION" ]]; then
+  echo '{"success":false,"error":"Missing required parameter: -Action"}'
+  exit 1
+fi
+
+if [[ -z "$PROCESS_ID" || "$PROCESS_ID" == "0" ]]; then
+  echo '{"success":false,"error":"Missing required parameter: -ProcessId"}'
+  exit 1
+fi
+
+# Map Windows ControlType to macOS role
+map_control_type() {
+  local ct="$1"
+  case "$ct" in
+    Button)       echo "button" ;;
+    Edit)         echo "text field" ;;
+    Text)         echo "static text" ;;
+    CheckBox)     echo "checkbox" ;;
+    RadioButton)  echo "radio button" ;;
+    ComboBox)     echo "pop up button" ;;
+    MenuItem)     echo "menu item" ;;
+    Menu)         echo "menu" ;;
+    List)         echo "list" ;;
+    ListItem)     echo "row" ;;
+    Tree)         echo "outline" ;;
+    TreeItem)     echo "row" ;;
+    Tab)          echo "tab group" ;;
+    TabItem)      echo "radio button" ;;
+    Window)       echo "window" ;;
+    *)            echo "" ;;
+  esac
+}
+
+# Determine search name (use Name or AutomationId)
+SEARCH_NAME="${NAME:-$AUTOMATION_ID}"
+
+# For actions that can use the existing invoke-element.jxa
+case "$ACTION" in
+  click|set-value|get-value|focus)
+    # Build JXA arguments
+    JXA_ARGS=("-action" "$ACTION" "-processId" "$PROCESS_ID")
+    
+    if [[ -n "$SEARCH_NAME" ]]; then
+      JXA_ARGS+=("-name" "$SEARCH_NAME")
+    fi
+    
+    if [[ -n "$CONTROL_TYPE" ]]; then
+      MAPPED_ROLE=$(map_control_type "$CONTROL_TYPE")
+      if [[ -n "$MAPPED_ROLE" ]]; then
+        JXA_ARGS+=("-role" "$MAPPED_ROLE")
+      fi
+    fi
+    
+    if [[ -n "$VALUE" ]]; then
+      JXA_ARGS+=("-value" "$VALUE")
+    fi
+    
+    # Run invoke-element.jxa
+    osascript -l JavaScript "$SCRIPT_DIR/invoke-element.jxa" "${JXA_ARGS[@]}" 2>/dev/null || \
+      echo '{"success":false,"error":"JXA script failed"}'
+    ;;
+    
+  sendkeys)
+    # Focus the element, then use System Events keystroke
+    if [[ -z "$VALUE" ]]; then
+      echo '{"success":false,"error":"Value parameter required for sendkeys action"}'
+      exit 0
+    fi
+    
+    # First focus the element
+    JXA_ARGS=("-action" "focus" "-processId" "$PROCESS_ID")
+    if [[ -n "$SEARCH_NAME" ]]; then
+      JXA_ARGS+=("-name" "$SEARCH_NAME")
+    fi
+    
+    FOCUS_RESULT=$(osascript -l JavaScript "$SCRIPT_DIR/invoke-element.jxa" "${JXA_ARGS[@]}" 2>/dev/null || echo '{"success":false}')
+    
+    # Check if focus succeeded
+    FOCUS_OK=$(echo "$FOCUS_RESULT" | /usr/bin/python3 -c "import sys,json; d=json.load(sys.stdin); print('true' if d.get('success') else 'false')" 2>/dev/null || echo "false")
+    
+    if [[ "$FOCUS_OK" != "true" ]]; then
+      echo '{"success":false,"error":"Failed to focus element for sendkeys"}'
+      exit 0
+    fi
+    
+    # Small delay for focus to take effect
+    sleep 0.1
+    
+    # Send keystrokes via System Events (sanitize input via python3)
+    SAFE_VALUE=$(/usr/bin/python3 -c "import sys,json; print(json.dumps(sys.argv[1]))" "$VALUE" 2>/dev/null)
+    # SAFE_VALUE is now a JSON-quoted string like "hello \"world\""
+    # Strip outer quotes for AppleScript
+    SAFE_VALUE=${SAFE_VALUE:1:-1}
+    osascript -e "
+      tell application \"System Events\"
+        keystroke \"${SAFE_VALUE}\"
+      end tell
+    " 2>/dev/null
+    
+    if [[ $? -eq 0 ]]; then
+      echo "{\"success\":true,\"action\":\"sendkeys\",\"method\":\"keystroke\",\"value\":$(echo "$VALUE" | /usr/bin/python3 -c 'import sys,json; print(json.dumps(sys.stdin.read().strip()))')}"
+    else
+      echo '{"success":false,"error":"keystroke failed"}'
+    fi
+    ;;
+    
+  toggle)
+    # Toggle a checkbox: click it to toggle state
+    JXA_ARGS=("-action" "click" "-processId" "$PROCESS_ID")
+    if [[ -n "$SEARCH_NAME" ]]; then
+      JXA_ARGS+=("-name" "$SEARCH_NAME")
+    fi
+    if [[ -n "$CONTROL_TYPE" ]]; then
+      MAPPED_ROLE=$(map_control_type "$CONTROL_TYPE")
+      if [[ -n "$MAPPED_ROLE" ]]; then
+        JXA_ARGS+=("-role" "$MAPPED_ROLE")
+      fi
+    fi
+    
+    RESULT=$(osascript -l JavaScript "$SCRIPT_DIR/invoke-element.jxa" "${JXA_ARGS[@]}" 2>/dev/null || echo '{"success":false}')
+    
+    # Rewrite the result to indicate toggle action
+    echo "$RESULT" | /usr/bin/python3 -c "
+import sys, json
+try:
+    d = json.load(sys.stdin)
+    d['action'] = 'toggle'
+    if d.get('success'):
+        d['method'] = 'click-toggle'
+    print(json.dumps(d, separators=(',', ':')))
+except:
+    print('{\"success\":false,\"error\":\"toggle failed\"}')" 2>/dev/null || echo '{"success":false,"error":"toggle failed"}'
+    ;;
+    
+  expand|collapse)
+    # macOS doesn't have ExpandCollapsePattern directly.
+    # Try AXPress action (works for disclosure triangles) or click
+    JXA_ARGS=("-action" "click" "-processId" "$PROCESS_ID")
+    if [[ -n "$SEARCH_NAME" ]]; then
+      JXA_ARGS+=("-name" "$SEARCH_NAME")
+    fi
+    
+    RESULT=$(osascript -l JavaScript "$SCRIPT_DIR/invoke-element.jxa" "${JXA_ARGS[@]}" 2>/dev/null || echo '{"success":false}')
+    
+    echo "$RESULT" | /usr/bin/python3 -c "
+import sys, json
+try:
+    d = json.load(sys.stdin)
+    d['action'] = '${ACTION}'
+    if d.get('success'):
+        d['method'] = 'click-${ACTION}'
+    print(json.dumps(d, separators=(',', ':')))
+except:
+    print('{\"success\":false,\"error\":\"${ACTION} failed\"}')" 2>/dev/null || echo "{\"success\":false,\"error\":\"${ACTION} failed\"}"
+    ;;
+    
+  select)
+    # Select: click the item (works for list items, tabs, radio buttons)
+    JXA_ARGS=("-action" "click" "-processId" "$PROCESS_ID")
+    if [[ -n "$SEARCH_NAME" ]]; then
+      JXA_ARGS+=("-name" "$SEARCH_NAME")
+    fi
+    if [[ -n "$CONTROL_TYPE" ]]; then
+      MAPPED_ROLE=$(map_control_type "$CONTROL_TYPE")
+      if [[ -n "$MAPPED_ROLE" ]]; then
+        JXA_ARGS+=("-role" "$MAPPED_ROLE")
+      fi
+    fi
+    
+    RESULT=$(osascript -l JavaScript "$SCRIPT_DIR/invoke-element.jxa" "${JXA_ARGS[@]}" 2>/dev/null || echo '{"success":false}')
+    
+    echo "$RESULT" | /usr/bin/python3 -c "
+import sys, json
+try:
+    d = json.load(sys.stdin)
+    d['action'] = 'select'
+    if d.get('success'):
+        d['method'] = 'click-select'
+    print(json.dumps(d, separators=(',', ':')))
+except:
+    print('{\"success\":false,\"error\":\"select failed\"}')" 2>/dev/null || echo '{"success":false,"error":"select failed"}'
+    ;;
+    
+  *)
+    echo "{\"success\":false,\"error\":\"Unknown action: $ACTION\"}"
+    exit 0
+    ;;
+esac