@mseep/clawdcursor 1.5.5

package/scripts/mac/focus-window.jxa

@@ -0,0 +1,284 @@
+#!/usr/bin/env osascript -l JavaScript
+
+/**
+ * focus-window.jxa
+ *
+ * Brings a window to the front by title substring or process ID.
+ *
+ * Parameters:
+ *   -title <string>      - Substring match against window titles (case-insensitive)
+ *   -processId <number>  - Process ID to focus
+ *
+ * Returns JSON result with success status and window info.
+ *
+ * Note: At least one of -title or -processId must be specified.
+ *
+ * When BOTH are supplied, -title is used to disambiguate among that
+ * process's windows (multi-window apps like Xcode, VS Code, Chrome).
+ * The previous implementation always picked process.windows[0], which
+ * surfaced whichever popup was most recent (e.g. Xcode's "Downloads"
+ * popover at 1760,80 instead of the user's project window). See bug
+ * #2 of clawdcursor issue #101.
+ *
+ * Usage: osascript -l JavaScript focus-window.jxa -title "Safari"
+ *        osascript -l JavaScript focus-window.jxa -processId 1234
+ *        osascript -l JavaScript focus-window.jxa -processId 1234 -title "Amr Dabbas"
+ */
+
+// ── Inlined from scripts/mac/_window-picker.jxa ───────────────────
+// Keep these helpers in sync with _window-picker.jxa; osascript can't require().
+
+function safeGet(obj, property, defaultValue) {
+    try {
+        var val = obj[property]();
+        return (val !== undefined && val !== null) ? val : defaultValue;
+    } catch (e) {
+        return defaultValue;
+    }
+}
+
+function getWinBounds(win) {
+    var bounds = { x: 0, y: 0, width: 0, height: 0 };
+    try {
+        var p = win.position();
+        var s = win.size();
+        if (p && s) {
+            bounds.x = p[0] || 0;
+            bounds.y = p[1] || 0;
+            bounds.width = s[0] || 0;
+            bounds.height = s[1] || 0;
+        }
+    } catch (e) {}
+    return bounds;
+}
+
+function getWinSubrole(win) {
+    try { return win.subrole() || ''; } catch (e) {}
+    try { return win.attributes.byName('AXSubrole').value() || ''; } catch (e) {}
+    return '';
+}
+
+function isLikelyTrayTitle(title) {
+    if (!title) return false;
+    var t = String(title).trim().toLowerCase();
+    return t === 'downloads' || t === 'notifications' || t === 'updates' ||
+           t === 'inspector' || t === 'activity';
+}
+
+function scoreWindow(win, index) {
+    var bounds = getWinBounds(win);
+    var area = bounds.width * bounds.height;
+    if (area <= 0) return -Infinity;
+    var score = area;
+    var subrole = getWinSubrole(win);
+    if (subrole === 'AXStandardWindow') score += 2000000;
+    else if (subrole === 'AXFloatingWindow') score -= 5000000;
+    else if (subrole === 'AXDialog' || subrole === 'AXSystemDialog') score -= 3000000;
+    var title = '';
+    try { title = win.name() || ''; } catch (e) {}
+    if (isLikelyTrayTitle(title)) score -= 1500000;
+    score += index * 10;
+    return score;
+}
+
+function pickInteractionWindow(windows) {
+    var best = null, bestScore = -Infinity, bestIndex = -1;
+    for (var i = 0; i < windows.length; i++) {
+        try {
+            var s = scoreWindow(windows[i], i);
+            if (s > bestScore) { bestScore = s; best = windows[i]; bestIndex = i; }
+        } catch (e) {}
+    }
+    if (!best) return null;
+    return { window: best, index: bestIndex };
+}
+
+function findTitleMatchWindow(windows, needle) {
+    if (!needle) return null;
+    var n = String(needle).toLowerCase();
+    for (var i = 0; i < windows.length; i++) {
+        try {
+            var w = windows[i];
+            var title = '';
+            try { title = w.name() || ''; } catch (e) {}
+            if (!title) continue;
+            if (title.toLowerCase().indexOf(n) === -1) continue;
+            var b = getWinBounds(w);
+            if (b.width * b.height <= 0) continue;
+            return { window: w, index: i, title: title };
+        } catch (e) {}
+    }
+    return null;
+}
+
+// ── End inlined helpers ───────────────────────────────────────────
+
+// run(argv) is the JXA entry point — osascript calls it and its return value becomes stdout.
+// argv receives command-line arguments passed after the script path.
+function run(argv) {
+    try {
+        // Parse arguments from argv array
+        var params = { title: null, processId: null };
+        for (var i = 0; i < argv.length; i++) {
+            var a = argv[i];
+            var hasNext = i + 1 < argv.length;
+            if ((a === '-title' || a === '-Title') && hasNext) {
+                params.title = argv[++i];
+            } else if ((a === '-processId' || a === '-ProcessId') && hasNext) {
+                params.processId = parseInt(argv[++i], 10);
+            }
+            // -Restore has no direct macOS equivalent; silently ignore
+        }
+
+        // Validate parameters
+        if (!params.title && !params.processId) {
+            return JSON.stringify({
+                success: false,
+                error: 'Must specify -title or -processId'
+            });
+        }
+
+        var SystemEvents = Application('System Events');
+        SystemEvents.includeStandardAdditions = true;
+
+        // Get all processes with UI
+        var processes = SystemEvents.processes.where({ backgroundOnly: false });
+        var targetWindow = null;
+        var targetProcess = null;
+
+        // Phase 1: if processId is supplied, locate that process and pick
+        // the right window inside it. This is the bug #2 fix — when title
+        // is also supplied, the title MUST be consulted before defaulting
+        // to windows[0] (which on multi-window apps is often a popup).
+        if (params.processId) {
+            for (var pi = 0; pi < processes.length; pi++) {
+                try {
+                    var process = processes[pi];
+                    var pidHere = safeGet(process, 'unixId', 0);
+                    if (pidHere !== params.processId) continue;
+
+                    targetProcess = process;
+                    var windows = process.windows;
+
+                    if (windows.length === 0) break;
+
+                    // (a) Title-disambiguation inside the matched process
+                    if (params.title) {
+                        var hit = findTitleMatchWindow(windows, params.title);
+                        if (hit) { targetWindow = hit.window; break; }
+                    }
+
+                    // (b) No title or no title match — fall back to the
+                    // scored interaction window rather than blindly windows[0],
+                    // which would re-introduce the popup-grab regression.
+                    var picked = pickInteractionWindow(windows);
+                    if (picked) { targetWindow = picked.window; break; }
+
+                    // (c) Last resort: keep legacy behaviour so we never
+                    // regress to "matched process but no window".
+                    targetWindow = windows[0];
+                    break;
+                } catch (e) {
+                    // Process not accessible
+                }
+            }
+        }
+
+        // Phase 2: cross-process title scan, used when processId wasn't
+        // supplied or didn't match. Bug #2's second clause: this scan must
+        // skip 0x0 (invisible) windows that happen to share the title but
+        // can't actually be raised — those return success but do nothing.
+        if (!targetWindow && params.title) {
+            for (var pi2 = 0; pi2 < processes.length; pi2++) {
+                try {
+                    var p2 = processes[pi2];
+                    var ws = p2.windows;
+                    var hit2 = findTitleMatchWindow(ws, params.title);
+                    if (hit2) {
+                        targetWindow = hit2.window;
+                        targetProcess = p2;
+                        break;
+                    }
+                } catch (e) {
+                    // Process not accessible
+                }
+            }
+        }
+
+        if (!targetWindow) {
+            return JSON.stringify({
+                success: false,
+                error: 'Window not found matching title="' + (params.title || '') + '" processId=' + (params.processId || 0)
+            });
+        }
+
+        // Bring window to front
+        // Method 1: Use System Events to set frontmost
+        try {
+            if (targetProcess) {
+                targetProcess.frontmost = true;
+            }
+        } catch (e) {
+            // Continue with other methods
+        }
+
+        // Method 2: Focus the window
+        try {
+            targetWindow.focused = true;
+        } catch (e) {
+            // Continue
+        }
+
+        // Method 3: Use application level activation (if we can get the app name)
+        try {
+            if (targetProcess) {
+                var appName = safeGet(targetProcess, 'name', '');
+                if (appName) {
+                    var app = Application(appName);
+                    app.activate();
+                }
+            }
+        } catch (e) {
+            // Continue
+        }
+
+        // Method 4: AXRaise — the only call that, on multi-window apps, brings
+        // the SPECIFIC window forward instead of just activating the app and
+        // letting macOS surface whichever window was frontmost last. Without
+        // this, bug #2 would only be half-fixed: we'd pick the right window
+        // but app.activate() would still raise the app's most-recent window.
+        try {
+            targetWindow.actions.byName('AXRaise').perform();
+        } catch (e) {
+            // Not all windows expose AXRaise; ignore if unavailable.
+        }
+
+        // Get final window info
+        var winTitle = '';
+        var winProcessId = 0;
+        var winProcessName = 'unknown';
+        var winBounds = getWinBounds(targetWindow);
+        var winSubrole = getWinSubrole(targetWindow);
+
+        try {
+            winTitle = targetWindow.name() || '';
+        } catch (e) {}
+
+        if (targetProcess) {
+            winProcessId = safeGet(targetProcess, 'unixId', 0);
+            winProcessName = safeGet(targetProcess, 'name', 'unknown');
+        }
+
+        return JSON.stringify({
+            success: true,
+            title: winTitle,
+            processId: winProcessId,
+            processName: winProcessName,
+            bounds: winBounds,
+            subrole: winSubrole
+        });
+
+    } catch (error) {
+        return JSON.stringify({ success: false, error: error.toString() });
+    }
+}

package/scripts/mac/get-focused-element.jxa

@@ -0,0 +1,102 @@
+#!/usr/bin/env osascript -l JavaScript
+/**
+ * get-focused-element.jxa — returns the currently focused UI element on macOS.
+ *
+ * Output: JSON with name, role, value, bounds, processId.
+ * Matches the FocusedElementInfo shape from accessibility.ts.
+ */
+
+function run() {
+  const se = Application('System Events');
+  se.includeStandardAdditions = true;
+
+  try {
+    const procs = se.applicationProcesses.whose({ frontmost: true });
+    if (procs.length === 0) {
+      return JSON.stringify(null);
+    }
+
+    const proc = procs[0];
+    const pid = proc.unixId();
+    const procName = proc.name();
+
+    // Get the focused UI element
+    let focused;
+    try {
+      focused = proc.focusedUIElement();
+    } catch (e) {
+      // Some apps don't expose focused element — return window info instead
+      try {
+        const wins = proc.windows();
+        if (wins.length > 0) {
+          const win = wins[0];
+          const pos = win.position();
+          const sz = win.size();
+          return JSON.stringify({
+            name: win.name() || procName,
+            automationId: '',
+            controlType: 'Window',
+            className: procName,
+            processId: pid,
+            isEnabled: true,
+            bounds: { x: pos[0], y: pos[1], width: sz[0], height: sz[1] },
+            value: ''
+          });
+        }
+      } catch (_) {}
+      return JSON.stringify(null);
+    }
+
+    // Extract properties safely
+    let name = '', role = '', value = '';
+    let bounds = { x: 0, y: 0, width: 0, height: 0 };
+
+    try { name = focused.name() || ''; } catch (_) {}
+    try { role = focused.role() || ''; } catch (_) {}
+    try { value = String(focused.value() || ''); } catch (_) {}
+
+    try {
+      const pos = focused.position();
+      const sz = focused.size();
+      bounds = { x: pos[0], y: pos[1], width: sz[0], height: sz[1] };
+    } catch (_) {}
+
+    // Map AX roles to Windows ControlType names for compatibility
+    const roleMap = {
+      'AXTextField': 'Edit',
+      'AXTextArea': 'Edit',
+      'AXButton': 'Button',
+      'AXCheckBox': 'CheckBox',
+      'AXRadioButton': 'RadioButton',
+      'AXComboBox': 'ComboBox',
+      'AXList': 'List',
+      'AXTable': 'Table',
+      'AXMenu': 'Menu',
+      'AXMenuItem': 'MenuItem',
+      'AXStaticText': 'Text',
+      'AXImage': 'Image',
+      'AXLink': 'Hyperlink',
+      'AXGroup': 'Group',
+      'AXWindow': 'Window',
+      'AXWebArea': 'Document',
+      'AXScrollArea': 'ScrollBar',
+      'AXTab': 'Tab',
+      'AXSlider': 'Slider',
+    };
+
+    const controlType = roleMap[role] || role.replace('AX', '') || 'Unknown';
+
+    return JSON.stringify({
+      name: name,
+      automationId: '',
+      controlType: controlType,
+      className: procName,
+      processId: pid,
+      isEnabled: true,
+      bounds: bounds,
+      value: value
+    });
+  } catch (e) {
+    return JSON.stringify(null);
+  }
+}

package/scripts/mac/get-foreground-window.jxa

@@ -0,0 +1,173 @@
+#!/usr/bin/env osascript -l JavaScript
+
+/**
+ * get-foreground-window.jxa
+ *
+ * Gets the currently focused/foreground window.
+ *
+ * Returns JSON with:
+ *   - handle: Window identifier (on macOS this is the process ID as a proxy)
+ *   - processId: Unix process ID of the foreground application
+ *   - processName: Name of the foreground application
+ *   - title: Title of the chosen window
+ *   - bounds: {x, y, width, height} of the chosen window
+ *   - subrole: AXSubrole of the chosen window ("AXStandardWindow", etc.)
+ *   - success: Boolean indicating success
+ *
+ * Bug #4 of clawdcursor issue #101: the previous implementation took
+ * processes.where({frontmost: true})[0].windows[0], which on apps that
+ * spawn a popup (Xcode "Downloads", Safari "Notifications") returned the
+ * popup instead of the user's actual interaction window. We now score
+ * each window of the frontmost process and pick the best one.
+ *
+ * Usage: osascript -l JavaScript get-foreground-window.jxa
+ */
+
+// ── Inlined from scripts/mac/_window-picker.jxa ───────────────────
+// Keep these helpers in sync with _window-picker.jxa; osascript can't require().
+
+function safeGet(obj, property, defaultValue) {
+    try {
+        var val = obj[property]();
+        return (val !== undefined && val !== null) ? val : defaultValue;
+    } catch (e) {
+        return defaultValue;
+    }
+}
+
+function getWinBounds(win) {
+    var bounds = { x: 0, y: 0, width: 0, height: 0 };
+    try {
+        var p = win.position();
+        var s = win.size();
+        if (p && s) {
+            bounds.x = p[0] || 0;
+            bounds.y = p[1] || 0;
+            bounds.width = s[0] || 0;
+            bounds.height = s[1] || 0;
+        }
+    } catch (e) {}
+    return bounds;
+}
+
+function getWinSubrole(win) {
+    try { return win.subrole() || ''; } catch (e) {}
+    try { return win.attributes.byName('AXSubrole').value() || ''; } catch (e) {}
+    return '';
+}
+
+function isLikelyTrayTitle(title) {
+    if (!title) return false;
+    var t = String(title).trim().toLowerCase();
+    return t === 'downloads' || t === 'notifications' || t === 'updates' ||
+           t === 'inspector' || t === 'activity';
+}
+
+function scoreWindow(win, index) {
+    var bounds = getWinBounds(win);
+    var area = bounds.width * bounds.height;
+    if (area <= 0) return -Infinity;
+    var score = area;
+    var subrole = getWinSubrole(win);
+    if (subrole === 'AXStandardWindow') score += 2000000;
+    else if (subrole === 'AXFloatingWindow') score -= 5000000;
+    else if (subrole === 'AXDialog' || subrole === 'AXSystemDialog') score -= 3000000;
+    var title = '';
+    try { title = win.name() || ''; } catch (e) {}
+    if (isLikelyTrayTitle(title)) score -= 1500000;
+    score += index * 10;
+    return score;
+}
+
+function pickInteractionWindow(windows) {
+    var best = null, bestScore = -Infinity, bestIndex = -1;
+    for (var i = 0; i < windows.length; i++) {
+        try {
+            var s = scoreWindow(windows[i], i);
+            if (s > bestScore) { bestScore = s; best = windows[i]; bestIndex = i; }
+        } catch (e) {}
+    }
+    if (!best) return null;
+    return { window: best, index: bestIndex };
+}
+
+// ── End inlined helpers ───────────────────────────────────────────
+
+// run(argv) is the JXA entry point — osascript calls it and its return value becomes stdout.
+function run(argv) {
+    try {
+        var SystemEvents = Application('System Events');
+        SystemEvents.includeStandardAdditions = true;
+
+        // Get the frontmost process
+        var frontProcesses = SystemEvents.processes.where({ frontmost: true });
+
+        if (frontProcesses.length === 0) {
+            return JSON.stringify({
+                success: false,
+                error: 'No foreground window found'
+            });
+        }
+
+        var frontProcess = frontProcesses[0];
+        var processId = safeGet(frontProcess, 'unixId', 0);
+        var processName = safeGet(frontProcess, 'name', 'unknown');
+
+        // Pick the user's real interaction window instead of windows[0].
+        // See header comment for bug #4 rationale.
+        var title = '';
+        var bounds = { x: 0, y: 0, width: 0, height: 0 };
+        var subrole = '';
+
+        try {
+            var windows = frontProcess.windows;
+            if (windows.length > 0) {
+                var picked = pickInteractionWindow(windows);
+                var chosen = null;
+
+                if (picked) {
+                    chosen = picked.window;
+                } else {
+                    // No window had visible area — try a focused window as a
+                    // last resort before giving up on title/bounds entirely.
+                    for (var i = 0; i < windows.length; i++) {
+                        try {
+                            if (windows[i].focused && windows[i].focused()) {
+                                chosen = windows[i];
+                                break;
+                            }
+                        } catch (e) {}
+                    }
+                    // If still nothing, fall back to windows[0] purely for
+                    // title extraction — preserves prior behaviour when the
+                    // only available window is a popup.
+                    if (!chosen) chosen = windows[0];
+                }
+
+                try { title = chosen.name() || ''; } catch (e) {}
+                bounds = getWinBounds(chosen);
+                subrole = getWinSubrole(chosen);
+            }
+        } catch (e) {
+            // No windows accessible
+        }
+
+        // On macOS, we don't have window handles like Win32 HWND
+        // We use processId as a proxy identifier
+        return JSON.stringify({
+            success: true,
+            handle: processId,  // Using processId as handle equivalent
+            processId: processId,
+            processName: processName,
+            title: title,
+            bounds: bounds,
+            subrole: subrole
+        });
+
+    } catch (error) {
+        return JSON.stringify({
+            success: false,
+            error: error.toString()
+        });
+    }
+}