@mseep/clawdcursor 1.5.5

package/scripts/mac/invoke-element.jxa

@@ -0,0 +1,408 @@
+#!/usr/bin/env osascript -l JavaScript
+
+/**
+ * invoke-element.jxa
+ * 
+ * Finds a UI element and invokes an action on it.
+ * 
+ * Parameters:
+ *   -action <string>     - Required. One of: click | focus | set-value | get-value |
+ *                          expand | collapse | toggle | select
+ *   -name <string>       - Match elements by name (contains match, case-insensitive)
+ *   -role <string>       - Match elements by role (e.g., "button", "text field")
+ *   -processId <number>  - Required. The process ID of the target application
+ *   -value <string>      - Value to set (only used with set-value action)
+ * 
+ * Returns JSON result with success status and action-specific data.
+ * 
+ * Usage: osascript -l JavaScript invoke-element.jxa -action click -name "OK" -processId 1234
+ *        osascript -l JavaScript invoke-element.jxa -action set-value -name "Username" -value "john" -processId 1234
+ */
+
+// 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;
+    }
+}
+
+// Find element matching criteria
+function findElement(root, targetName, targetRole, maxDepth, currentDepth) {
+    if (currentDepth > maxDepth) {
+        return null;
+    }
+    
+    try {
+        var elName = '';
+        var elRole = '';
+        
+        try {
+            elName = root.name() || '';
+        } catch (e) {}
+        
+        try {
+            elRole = root.role() || '';
+        } catch (e) {}
+        
+        // Check if this element matches
+        var nameMatch = !targetName || 
+            (elName && elName.toLowerCase().indexOf(targetName.toLowerCase()) !== -1);
+        var roleMatch = !targetRole || 
+            (elRole && elRole.toLowerCase().indexOf(targetRole.toLowerCase()) !== -1);
+        
+        if (nameMatch && roleMatch && (elName || elRole)) {
+            return root;
+        }
+        
+        // Search children
+        try {
+            var children = root.uiElements();
+            for (var i = 0; i < children.length; i++) {
+                var found = findElement(children[i], targetName, targetRole, maxDepth, currentDepth + 1);
+                if (found) return found;
+            }
+        } catch (e) {}
+        
+        // Check specific element types
+        var elementTypes = ['buttons', 'textFields', 'popUpButtons', 'checkboxes', 'radioButtons', 'menus'];
+        for (var j = 0; j < elementTypes.length; j++) {
+            try {
+                var typedElements = root[elementTypes[j]]();
+                for (var k = 0; k < typedElements.length; k++) {
+                    var found = findElement(typedElements[k], targetName, targetRole, maxDepth, currentDepth + 1);
+                    if (found) return found;
+                }
+            } catch (e) {}
+        }
+    } catch (e) {}
+    
+    return null;
+}
+
+// Get element bounds for coordinate fallback
+function getElementBounds(element) {
+    try {
+        if (element.position && element.size) {
+            var pos = element.position();
+            var sz = element.size();
+            return {
+                x: pos[0] || 0,
+                y: pos[1] || 0,
+                width: sz[0] || 0,
+                height: sz[1] || 0
+            };
+        }
+    } catch (e) {}
+    return null;
+}
+
+// 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 = { 
+            action: null,
+            name: null, 
+            role: null, 
+            processId: null,
+            value: null
+        };
+        // Windows ControlType → macOS AX role mapping (mirrors find-element.jxa)
+        var CONTROL_TYPE_MAP = {
+            'Button': 'button', 'Edit': 'text field', 'Document': 'web area',
+            'ComboBox': 'pop up button', 'CheckBox': 'checkbox',
+            'RadioButton': 'radio button', 'Hyperlink': 'link',
+            'MenuItem': 'menu item', 'Menu': 'menu', 'Tab': 'tab group',
+            'TabItem': 'radio button', 'ListItem': 'row', 'TreeItem': 'row',
+            'Slider': 'slider', 'ScrollBar': 'scroll bar',
+            'ToolBar': 'toolbar', 'StaticText': 'static text', 'Window': 'window'
+        };
+
+        for (var i = 0; i < argv.length; i++) {
+            var a = argv[i];
+            var hasNext = i + 1 < argv.length;
+            if ((a === '-action' || a === '-Action') && hasNext) {
+                params.action = argv[++i];
+            } else if ((a === '-name' || a === '-Name') && hasNext) {
+                params.name = argv[++i];
+            } else if ((a === '-role') && hasNext) {
+                params.role = argv[++i];
+            } else if (a === '-ControlType' && hasNext) {
+                var ct = argv[++i];
+                params.role = CONTROL_TYPE_MAP[ct] || ct.toLowerCase();
+            } else if ((a === '-processId' || a === '-ProcessId' || a === '-FocusedProcessId') && hasNext) {
+                // -FocusedProcessId accepted as an alias for callers that share
+                // arg-building with get-screen-context.jxa (defense-in-depth).
+                params.processId = parseInt(argv[++i], 10);
+            } else if ((a === '-value' || a === '-Value') && hasNext) {
+                params.value = argv[++i];
+            }
+            // -AutomationId and -Restore have no macOS equivalent; silently ignore
+        }
+
+        // Validate required parameters
+        if (!params.action) {
+            return JSON.stringify({ 
+                success: false, 
+                error: 'Missing required parameter: -action' 
+            });
+        }
+        
+        if (!params.processId) {
+            return JSON.stringify({ 
+                success: false, 
+                error: 'Missing required parameter: -processId' 
+            });
+        }
+        
+        var SystemEvents = Application('System Events');
+        SystemEvents.includeStandardAdditions = true;
+        
+        // Find the target process
+        var targetProcess = null;
+        var processes = SystemEvents.processes.where({ unixId: params.processId });
+        
+        if (processes.length === 0) {
+            return JSON.stringify({ 
+                success: false, 
+                error: 'No process found with ID ' + params.processId 
+            });
+        }
+        
+        targetProcess = processes[0];
+        
+        // Find target element
+        var targetElement = null;
+        var windows = targetProcess.windows;
+        
+        for (var w = 0; w < windows.length && !targetElement; w++) {
+            targetElement = findElement(windows[w], params.name, params.role, 10, 0);
+        }
+        
+        if (!targetElement) {
+            var searchDesc = '';
+            if (params.name) searchDesc += 'name="' + params.name + '" ';
+            if (params.role) searchDesc += 'role="' + params.role + '" ';
+            return JSON.stringify({ 
+                success: false, 
+                error: 'Element not found: ' + searchDesc.trim() 
+            });
+        }
+        
+        // Execute the requested action
+        var result = { success: false };
+        
+        switch (params.action) {
+            case 'click':
+                try {
+                    targetElement.click();
+                    result = { 
+                        success: true, 
+                        action: 'click',
+                        method: 'click()'
+                    };
+                } catch (e) {
+                    // Fallback: return bounds for coordinate click
+                    var bounds = getElementBounds(targetElement);
+                    if (bounds) {
+                        result = {
+                            success: false,
+                            action: 'click',
+                            error: 'Element does not support click(). Use coordinate click.',
+                            clickPoint: {
+                                x: bounds.x + Math.floor(bounds.width / 2),
+                                y: bounds.y + Math.floor(bounds.height / 2)
+                            }
+                        };
+                    } else {
+                        result = {
+                            success: false,
+                            action: 'click',
+                            error: 'Click failed and no bounds available: ' + e.toString()
+                        };
+                    }
+                }
+                break;
+                
+            case 'set-value':
+                if (params.value === null) {
+                    result = {
+                        success: false,
+                        error: 'Value parameter required for set-value action'
+                    };
+                } else {
+                    try {
+                        targetElement.value = params.value;
+                        result = {
+                            success: true,
+                            action: 'set-value',
+                            value: params.value
+                        };
+                    } catch (e) {
+                        // Try setting through focused property
+                        try {
+                            targetElement.focused = true;
+                            // Use System Events to type the value
+                            var app = Application.currentApplication();
+                            app.includeStandardAdditions = true;
+                            app.keystroke(params.value);
+                            result = {
+                                success: true,
+                                action: 'set-value',
+                                value: params.value,
+                                method: 'keystroke'
+                            };
+                        } catch (ke) {
+                            result = {
+                                success: false,
+                                error: 'Failed to set value: ' + e.toString()
+                            };
+                        }
+                    }
+                }
+                break;
+                
+            case 'get-value':
+                // Prefer AXValue, but fall back to the name property when AXValue
+                // is absent OR empty. Some controls expose an AXValue that reads
+                // "" while the real text is only in the title/name — returning the
+                // empty string there caused false "value did not change" reads
+                // (parity with the Windows ValuePattern→TextPattern fix).
+                var gotVal = null, gotMethod = null;
+                try {
+                    var val = targetElement.value();
+                    if (val !== null && val !== undefined && String(val).length > 0) {
+                        gotVal = val; gotMethod = 'AXValue';
+                    }
+                } catch (e) { /* no AXValue — try name */ }
+                if (gotVal === null) {
+                    try {
+                        var name = targetElement.name();
+                        if (name !== null && name !== undefined && String(name).length > 0) {
+                            gotVal = name; gotMethod = 'name';
+                        }
+                    } catch (ne) { /* no name either */ }
+                }
+                if (gotVal !== null) {
+                    result = { success: true, action: 'get-value', value: gotVal, method: gotMethod };
+                } else {
+                    // Genuinely empty (e.g. an empty field) — report "" success, not an error.
+                    result = { success: true, action: 'get-value', value: '', method: 'empty' };
+                }
+                break;
+                
+            case 'focus':
+                try {
+                    targetElement.focused = true;
+                    result = {
+                        success: true,
+                        action: 'focus'
+                    };
+                } catch (e) {
+                    result = {
+                        success: false,
+                        error: 'Failed to set focus: ' + e.toString()
+                    };
+                }
+                break;
+
+            // ── Tranche 1A: AX Expand/Collapse/Toggle/Select ────────────
+            // macOS AX exposes these through attributes (`AXExpanded`,
+            // `AXValue` for checkboxes) rather than actions. JXA lets us
+            // set them directly. Failing gracefully when an element
+            // doesn't support the attribute is important — UIA-style
+            // pattern-query equivalents don't exist on AX, so we just
+            // attempt the assignment and catch.
+            case 'expand':
+                try {
+                    targetElement.attributes['AXExpanded'].value = true;
+                    result = { success: true, action: 'expand' };
+                } catch (e) {
+                    try {
+                        // Menu-style elements respond to AXShowMenu action.
+                        targetElement.actions['AXShowMenu'].perform();
+                        result = { success: true, action: 'expand', method: 'AXShowMenu' };
+                    } catch (e2) {
+                        result = {
+                            success: false,
+                            error: 'Element does not support expand (no AXExpanded attribute or AXShowMenu action)'
+                        };
+                    }
+                }
+                break;
+
+            case 'collapse':
+                try {
+                    targetElement.attributes['AXExpanded'].value = false;
+                    result = { success: true, action: 'collapse' };
+                } catch (e) {
+                    result = {
+                        success: false,
+                        error: 'Element does not support collapse (no AXExpanded attribute)'
+                    };
+                }
+                break;
+
+            case 'toggle':
+                // Checkboxes / radios expose AXValue as 0/1.
+                try {
+                    var currentValue;
+                    try { currentValue = targetElement.attributes['AXValue'].value; }
+                    catch (vErr) { currentValue = 0; }
+                    var newValue = currentValue ? 0 : 1;
+                    targetElement.attributes['AXValue'].value = newValue;
+                    result = {
+                        success: true,
+                        action: 'toggle',
+                        data: { toggleState: newValue ? 'On' : 'Off' }
+                    };
+                } catch (e) {
+                    // Fallback: invoke a click (AXPress) — matches UIA Toggle semantics.
+                    try {
+                        targetElement.actions['AXPress'].perform();
+                        result = { success: true, action: 'toggle', method: 'AXPress' };
+                    } catch (e2) {
+                        result = {
+                            success: false,
+                            error: 'Element does not support toggle (no AXValue or AXPress)'
+                        };
+                    }
+                }
+                break;
+
+            case 'select':
+                // AX uses AXSelected attribute for list items / tabs.
+                try {
+                    targetElement.attributes['AXSelected'].value = true;
+                    result = { success: true, action: 'select' };
+                } catch (e) {
+                    // Some pickers use AXPick / AXMenuItemMark attributes — try AXPress as last resort.
+                    try {
+                        targetElement.actions['AXPress'].perform();
+                        result = { success: true, action: 'select', method: 'AXPress' };
+                    } catch (e2) {
+                        result = {
+                            success: false,
+                            error: 'Element does not support select (no AXSelected attribute or AXPress action)'
+                        };
+                    }
+                }
+                break;
+
+            default:
+                result = {
+                    success: false,
+                    error: 'Unknown action: ' + params.action
+                };
+        }
+        
+        return JSON.stringify(result);
+        
+    } catch (error) {
+        return JSON.stringify({ success: false, error: error.toString() });
+    }
+}

package/scripts/mac/ocr-recognize.swift

@@ -0,0 +1,124 @@
+#!/usr/bin/env swift
+// macOS OCR via Vision framework (VNRecognizeTextRequest)
+// Takes an image path, outputs JSON result to stdout.
+// Matches the same JSON format as ocr-recognize.ps1 (Windows).
+//
+// Usage: swift ocr-recognize.swift /path/to/image.png
+
+import Foundation
+import Vision
+import AppKit
+
+guard CommandLine.arguments.count > 1 else {
+    let err: [String: Any] = ["error": "Usage: ocr-recognize.swift <image-path>"]
+    if let data = try? JSONSerialization.data(withJSONObject: err),
+       let str = String(data: data, encoding: .utf8) {
+        print(str)
+    }
+    exit(0)
+}
+
+let imagePath = CommandLine.arguments[1]
+let imageURL = URL(fileURLWithPath: imagePath)
+
+guard let image = NSImage(contentsOf: imageURL),
+      let cgImage = image.cgImage(forProposedRect: nil, context: nil, hints: nil) else {
+    let err: [String: Any] = ["error": "Failed to load image: \(imagePath)"]
+    if let data = try? JSONSerialization.data(withJSONObject: err),
+       let str = String(data: data, encoding: .utf8) {
+        print(str)
+    }
+    exit(0)
+}
+
+let imageWidth = CGFloat(cgImage.width)
+let imageHeight = CGFloat(cgImage.height)
+
+let semaphore = DispatchSemaphore(value: 0)
+var elements: [[String: Any]] = []
+var fullText = ""
+
+let request = VNRecognizeTextRequest { request, error in
+    defer { semaphore.signal() }
+
+    if let error = error {
+        let err: [String: Any] = ["error": "OCR failed: \(error.localizedDescription)"]
+        if let data = try? JSONSerialization.data(withJSONObject: err),
+           let str = String(data: data, encoding: .utf8) {
+            print(str)
+        }
+        return
+    }
+
+    guard let observations = request.results as? [VNRecognizedTextObservation] else { return }
+
+    var lineIdx = 0
+    var lines: [String] = []
+
+    for observation in observations {
+        guard let candidate = observation.topCandidates(1).first else { continue }
+        let text = candidate.string
+        let confidence = candidate.confidence
+        let box = observation.boundingBox
+
+        // Vision coordinates: origin bottom-left, normalized 0-1
+        // Convert to screen pixels: origin top-left
+        let x = box.origin.x * imageWidth
+        let y = (1.0 - box.origin.y - box.height) * imageHeight
+        let w = box.width * imageWidth
+        let h = box.height * imageHeight
+
+        // Split into words for per-word bounding boxes (approximate)
+        let words = text.components(separatedBy: " ")
+        let wordWidth = w / CGFloat(max(words.count, 1))
+
+        for (i, word) in words.enumerated() {
+            guard !word.isEmpty else { continue }
+            let element: [String: Any] = [
+                "text": word,
+                "x": Int(round(x + wordWidth * CGFloat(i))),
+                "y": Int(round(y)),
+                "width": Int(round(wordWidth)),
+                "height": Int(round(h)),
+                "confidence": round(Double(confidence) * 100) / 100,
+                "line": lineIdx
+            ]
+            elements.append(element)
+        }
+
+        lines.append(text)
+        lineIdx += 1
+    }
+
+    fullText = lines.joined(separator: "\n")
+}
+
+// Configure for accuracy (fast is also available)
+request.recognitionLevel = .accurate
+request.usesLanguageCorrection = true
+
+let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])
+do {
+    try handler.perform([request])
+} catch {
+    let err: [String: Any] = ["error": "VNImageRequestHandler failed: \(error.localizedDescription)"]
+    if let data = try? JSONSerialization.data(withJSONObject: err),
+       let str = String(data: data, encoding: .utf8) {
+        print(str)
+    }
+    exit(0)
+}
+
+// Wait for async completion
+semaphore.wait()
+
+// Output JSON matching Windows format
+let result: [String: Any] = [
+    "elements": elements,
+    "fullText": fullText
+]
+
+if let data = try? JSONSerialization.data(withJSONObject: result),
+   let str = String(data: data, encoding: .utf8) {
+    print(str)
+}

package/scripts/ocr-recognize.ps1

@@ -0,0 +1,102 @@
+# OCR Recognition via Windows.Media.Ocr WinRT API
+# Takes an image path, runs OCR, outputs JSON result to stdout.
+# Called one-shot per OCR request (results cached in TypeScript layer).
+
+param([string]$ImagePath)
+
+# Force UTF-8 on stdout so non-ASCII recognized text (emoji, accented
+# characters, CJK) survives the round-trip to Node. PowerShell defaults
+# to the system code page; Node decodes as UTF-8.
+[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+$OutputEncoding           = [System.Text.Encoding]::UTF8
+
+try {
+    # Resolve to absolute path (required by WinRT StorageFile API)
+    $ImagePath = (Resolve-Path $ImagePath -ErrorAction Stop).Path
+
+    # Load WinRT interop assembly
+    Add-Type -AssemblyName System.Runtime.WindowsRuntime
+
+    # Load WinRT types
+    $null = [Windows.Media.Ocr.OcrEngine, Windows.Foundation, ContentType = WindowsRuntime]
+    $null = [Windows.Graphics.Imaging.SoftwareBitmap, Windows.Foundation, ContentType = WindowsRuntime]
+    $null = [Windows.Graphics.Imaging.BitmapDecoder, Windows.Foundation, ContentType = WindowsRuntime]
+    $null = [Windows.Storage.StorageFile, Windows.Foundation, ContentType = WindowsRuntime]
+    $null = [Windows.Storage.Streams.RandomAccessStream, Windows.Foundation, ContentType = WindowsRuntime]
+
+    # Find the AsTask<TResult>(IAsyncOperation<TResult>) extension method
+    $asTaskOp = [System.WindowsRuntimeSystemExtensions].GetMethods() | Where-Object {
+        $_.Name -eq 'AsTask' -and
+        $_.IsGenericMethod -and
+        $_.GetParameters().Count -eq 1 -and
+        $_.GetParameters()[0].ParameterType.IsGenericType -and
+        $_.GetParameters()[0].ParameterType.GetGenericTypeDefinition().Name -eq 'IAsyncOperation`1'
+    } | Select-Object -First 1
+
+    if (-not $asTaskOp) {
+        [Console]::Out.WriteLine('{"error":"Cannot find AsTask method for WinRT async"}')
+        [Console]::Out.Flush()
+        exit 0
+    }
+
+    function Invoke-Async {
+        param([object]$AsyncOp, [Type]$ResultType)
+        $genericMethod = $script:asTaskOp.MakeGenericMethod($ResultType)
+        $task = $genericMethod.Invoke($null, @($AsyncOp))
+        $task.Wait() | Out-Null
+        return $task.Result
+    }
+
+    # Create OCR engine from user profile languages
+    $ocr = [Windows.Media.Ocr.OcrEngine]::TryCreateFromUserProfileLanguages()
+    if (-not $ocr) {
+        [Console]::Out.WriteLine('{"error":"Windows OCR engine not available - no recognized languages installed"}')
+        [Console]::Out.Flush()
+        exit 0
+    }
+
+    # Open image via WinRT StorageFile → stream → BitmapDecoder → SoftwareBitmap
+    $storageFile = Invoke-Async ([Windows.Storage.StorageFile]::GetFileFromPathAsync($ImagePath)) ([Windows.Storage.StorageFile])
+    $stream      = Invoke-Async ($storageFile.OpenAsync([Windows.Storage.FileAccessMode]::Read)) ([Windows.Storage.Streams.IRandomAccessStream])
+    $decoder     = Invoke-Async ([Windows.Graphics.Imaging.BitmapDecoder]::CreateAsync($stream)) ([Windows.Graphics.Imaging.BitmapDecoder])
+    $bitmap      = Invoke-Async ($decoder.GetSoftwareBitmapAsync()) ([Windows.Graphics.Imaging.SoftwareBitmap])
+
+    # Run OCR recognition
+    $ocrResult = Invoke-Async ($ocr.RecognizeAsync($bitmap)) ([Windows.Media.Ocr.OcrResult])
+
+    # Build structured result — one entry per word with bounding box
+    $elements = @()
+    $lineIdx = 0
+    foreach ($line in $ocrResult.Lines) {
+        foreach ($word in $line.Words) {
+            $r = $word.BoundingRect
+            $elements += [PSCustomObject]@{
+                text       = ($word.Text -replace '[\x00-\x08\x0B\x0C\x0E-\x1F]', '')
+                x          = [math]::Round($r.X)
+                y          = [math]::Round($r.Y)
+                width      = [math]::Round($r.Width)
+                height     = [math]::Round($r.Height)
+                confidence = 1.0   # Windows.Media.Ocr does not expose per-word confidence
+                line       = $lineIdx
+            }
+        }
+        $lineIdx++
+    }
+
+    # Clean up WinRT resources
+    try { $stream.Dispose() } catch {}
+    try { $bitmap.Dispose() } catch {}
+
+    # Output single-line JSON
+    $output = [PSCustomObject]@{
+        elements = @($elements)   # force array even if 0 or 1 element
+        fullText = if ($ocrResult.Text) { $ocrResult.Text } else { "" }
+    }
+    [Console]::Out.WriteLine(($output | ConvertTo-Json -Depth 3 -Compress))
+    [Console]::Out.Flush()
+
+} catch {
+    [Console]::Out.WriteLine((@{ error = $_.Exception.Message } | ConvertTo-Json -Compress))
+    [Console]::Out.Flush()
+    exit 0
+}

package/scripts/postinstall-native.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+/**
+ * macOS-only postinstall step (issue #149).
+ *
+ * The published npm package ships the Swift SOURCES for the native helper
+ * but not a prebuilt binary. Without the binary, screenshots / display
+ * enumeration / TCC permission checks all fail. This script builds the
+ * helper from the shipped sources on a fresh `npm i -g clawdcursor` so a
+ * Mac user gets a working install out of the box.
+ *
+ * Best-effort by design: it NEVER fails the install. If the Xcode toolchain
+ * (`swift`) is absent, it prints actionable guidance and exits 0 — the
+ * runtime emits the same guidance the first time a screenshot is needed.
+ *
+ * No-op on Windows/Linux.
+ */
+'use strict';
+const { execFileSync, execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+if (process.platform !== 'darwin') process.exit(0);
+
+const root = path.join(__dirname, '..');
+const nativeDir = path.join(root, 'native');
+const buildSh = path.join(nativeDir, 'build.sh');
+
+// Dev checkouts / odd layouts: if sources aren't present, there's nothing to do.
+if (!fs.existsSync(buildSh)) process.exit(0);
+
+// Is the Swift toolchain available?
+try {
+  execSync('command -v swift', { stdio: 'ignore', shell: '/bin/bash' });
+} catch {
+  console.log('[clawdcursor] Native macOS helper not built — Xcode Command Line Tools (swift) not found.');
+  console.log('             Screenshots, display enumeration, and permission checks need it.');
+  console.log('             Install the tools, then build:  xcode-select --install  &&  cd "' + nativeDir + '" && ./build.sh');
+  process.exit(0);
+}
+
+try {
+  console.log('[clawdcursor] Building native macOS helper from source (native/build.sh)…');
+  execFileSync('/bin/bash', [buildSh], { stdio: 'inherit', cwd: nativeDir });
+  console.log('[clawdcursor] Native macOS helper built.');
+} catch (_e) {
+  console.log('[clawdcursor] Native macOS helper build failed (non-fatal). Build manually with: cd native && ./build.sh');
+}
+process.exit(0);