@mseep/clawdcursor 1.5.5

package/native/Sources/ClawdCursorHost/main.swift

@@ -0,0 +1,182 @@
+import Foundation
+import AppKit
+import ApplicationServices
+import CoreGraphics
+import Network
+
+private let hostPort: UInt16 = {
+    if let env = ProcessInfo.processInfo.environment["CLAWDCURSOR_HOST_PORT"], let parsed = UInt16(env) {
+        return parsed
+    }
+    return 3848
+}()
+
+private func expectedToken() -> String? {
+    let home = FileManager.default.homeDirectoryForCurrentUser
+    let tokenPath = home.appendingPathComponent(".clawdcursor/host-token").path
+    return try? String(contentsOfFile: tokenPath, encoding: .utf8).trimmingCharacters(in: .whitespacesAndNewlines)
+}
+
+private func jsonResponse(status: Int, payload: Data) -> Data {
+    var response = "HTTP/1.1 \(status) \(status == 200 ? "OK" : "ERROR")\r\n"
+    response += "Content-Type: application/json\r\n"
+    response += "Content-Length: \(payload.count)\r\n"
+    response += "Connection: close\r\n\r\n"
+    var data = Data(response.utf8)
+    data.append(payload)
+    return data
+}
+
+private func textResponse(status: Int, text: String) -> Data {
+    jsonResponse(status: status, payload: Data(text.utf8))
+}
+
+private func runBinary(_ binary: String, args: [String] = [], stdin: Data? = nil) -> (exitCode: Int32, stdout: Data, stderr: Data) {
+    let bundlePath = Bundle.main.bundlePath
+    let macOSDir = URL(fileURLWithPath: bundlePath).appendingPathComponent("Contents/MacOS")
+    let binaryPath = macOSDir.appendingPathComponent(binary).path
+
+    let process = Process()
+    let out = Pipe()
+    let err = Pipe()
+    let input = Pipe()
+
+    process.executableURL = URL(fileURLWithPath: binaryPath)
+    process.arguments = args
+    process.standardOutput = out
+    process.standardError = err
+    process.standardInput = input
+
+    do {
+        try process.run()
+    } catch {
+        return (1, Data(), Data("{\"error\":\"failed_to_launch_binary\"}".utf8))
+    }
+
+    if let stdin {
+        input.fileHandleForWriting.write(stdin)
+    }
+    try? input.fileHandleForWriting.close()
+
+    process.waitUntilExit()
+    let stdout = out.fileHandleForReading.readDataToEndOfFile()
+    let stderr = err.fileHandleForReading.readDataToEndOfFile()
+    return (process.terminationStatus, stdout, stderr)
+}
+
+private func handleRequest(raw: Data) -> Data {
+    guard let request = String(data: raw, encoding: .utf8) else {
+        return textResponse(status: 400, text: "{\"error\":\"invalid_utf8\"}")
+    }
+
+    let parts = request.components(separatedBy: "\r\n\r\n")
+    guard let head = parts.first else {
+        return textResponse(status: 400, text: "{\"error\":\"invalid_request\"}")
+    }
+
+    let lines = head.components(separatedBy: "\r\n")
+    guard let reqLine = lines.first else {
+        return textResponse(status: 400, text: "{\"error\":\"missing_request_line\"}")
+    }
+
+    let reqParts = reqLine.split(separator: " ")
+    guard reqParts.count >= 2 else {
+        return textResponse(status: 400, text: "{\"error\":\"bad_request_line\"}")
+    }
+
+    let method = String(reqParts[0])
+    let path = String(reqParts[1])
+    let body = parts.dropFirst().joined(separator: "\r\n\r\n")
+    var headers: [String: String] = [:]
+    for line in lines.dropFirst() {
+        if let idx = line.firstIndex(of: ":") {
+            let name = String(line[..<idx]).trimmingCharacters(in: .whitespaces).lowercased()
+            let value = String(line[line.index(after: idx)...]).trimmingCharacters(in: .whitespaces)
+            headers[name] = value
+        }
+    }
+
+    if method == "GET" && path == "/health" {
+        let payload = "{\"status\":\"ok\",\"service\":\"clawdcursor-host\",\"port\":\(hostPort)}"
+        return textResponse(status: 200, text: payload)
+    }
+
+    if method == "GET" && path == "/status" {
+        // Always delegate to the permission-check binary — it runs in the SAME
+        // app-bundle context (same TCC identity) and returns the canonical format
+        // including processPath + bundleId.  This keeps doctor, CLI status, and
+        // readiness.ts consistent.
+        let result = runBinary("permission-check", args: [])
+        if result.exitCode == 0, !result.stdout.isEmpty,
+           let text = String(data: result.stdout, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !text.isEmpty {
+            return textResponse(status: 200, text: text)
+        }
+
+        // Fallback: permission-check binary missing or crashed.
+        // Check directly but match the SAME JSON schema so callers don't break.
+        let axOptions = [kAXTrustedCheckOptionPrompt.takeUnretainedValue() as String: kCFBooleanFalse] as CFDictionary
+        let axGranted = AXIsProcessTrustedWithOptions(axOptions)
+        let screenGranted = CGPreflightScreenCaptureAccess()
+        let bundleId = Bundle.main.bundleIdentifier ?? "unknown"
+        let processPath = ProcessInfo.processInfo.arguments.first ?? "unknown"
+        let payload = "{\"accessibility\":\(axGranted),\"screenRecording\":\(screenGranted),\"processPath\":\"\(processPath)\",\"bundleId\":\"\(bundleId)\"}"
+        return textResponse(status: 200, text: payload)
+    }
+
+    if method == "POST" && path == "/rpc" {
+        guard let token = expectedToken(), !token.isEmpty else {
+            return textResponse(status: 503, text: "{\"error\":\"host_token_missing\"}")
+        }
+        guard headers["x-clawdcursor-token"] == token else {
+            return textResponse(status: 401, text: "{\"error\":\"unauthorized\"}")
+        }
+        let result = runBinary("clawdcursor-helper", stdin: Data((body + "\n").utf8))
+        if result.exitCode == 0, !result.stdout.isEmpty {
+            let lines = String(data: result.stdout, encoding: .utf8)?.split(separator: "\n") ?? []
+            if let first = lines.first {
+                return textResponse(status: 200, text: String(first))
+            }
+        }
+        let stderr = String(data: result.stderr, encoding: .utf8) ?? "unknown error"
+        return textResponse(status: 500, text: "{\"error\":\"helper_failed\",\"message\":\"\(stderr.replacingOccurrences(of: "\"", with: "'"))\"}")
+    }
+
+    return textResponse(status: 404, text: "{\"error\":\"not_found\"}")
+}
+
+private var listenerRef: NWListener?
+
+private func startServer() throws {
+    // SECURITY: Bind to localhost only — reject connections from other machines
+    let params = NWParameters.tcp
+    params.requiredLocalEndpoint = NWEndpoint.hostPort(host: .ipv4(.loopback), port: NWEndpoint.Port(rawValue: hostPort)!)
+    let listener = try NWListener(using: params)
+    listener.newConnectionHandler = { conn in
+        conn.start(queue: .global())
+        conn.receive(minimumIncompleteLength: 1, maximumLength: 1024 * 1024) { data, _, _, _ in
+            let response = handleRequest(raw: data ?? Data())
+            conn.send(content: response, completion: .contentProcessed { _ in
+                conn.cancel()
+            })
+        }
+    }
+    listener.start(queue: .global())
+    listenerRef = listener
+}
+
+let app = NSApplication.shared
+app.setActivationPolicy(.accessory)
+
+if let bundleId = Bundle.main.bundleIdentifier {
+    NSLog("ClawdCursorHost starting (bundle: \(bundleId), port: \(hostPort))")
+}
+
+try startServer()
+DispatchQueue.main.async {
+    let statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
+    statusItem.button?.title = "🐾"
+    statusItem.button?.toolTip = "ClawdCursor Host"
+}
+
+app.run()

package/native/Sources/PermissionCheck/main.swift

@@ -0,0 +1,53 @@
+/// permission-check - Quick permission status checker for Node.js integration
+/// Returns JSON: {"accessibility": bool, "screenRecording": bool}
+/// Use AXTrustedCheckOptionPrompt: true to trigger the system prompt dialog
+
+import Foundation
+import ApplicationServices
+import CoreGraphics
+
+struct PermissionStatus: Codable {
+    let accessibility: Bool
+    let screenRecording: Bool
+    let processPath: String
+    let bundleId: String?
+}
+
+// Check Accessibility permission (does NOT prompt - use --prompt flag for that)
+// Pattern from mediar-ai/MacosUseSDK - use kCFBooleanTrue/False explicitly
+let shouldPrompt = CommandLine.arguments.contains("--prompt")
+let promptValue: CFBoolean = shouldPrompt ? kCFBooleanTrue : kCFBooleanFalse
+let axOptions = [kAXTrustedCheckOptionPrompt.takeUnretainedValue() as String: promptValue] as CFDictionary
+let axGranted = AXIsProcessTrustedWithOptions(axOptions)
+
+// Check Screen Recording permission
+// CGPreflightScreenCaptureAccess() returns current state without prompting
+// CGRequestScreenCaptureAccess() triggers the system prompt dialog
+let shouldRequestScreen = CommandLine.arguments.contains("--request-screen-recording")
+let screenGranted: Bool
+if shouldRequestScreen {
+    screenGranted = CGRequestScreenCaptureAccess()
+} else {
+    screenGranted = CGPreflightScreenCaptureAccess()
+}
+
+// Get process info for debugging
+let processPath = ProcessInfo.processInfo.arguments[0]
+let bundleId = Bundle.main.bundleIdentifier
+
+let status = PermissionStatus(
+    accessibility: axGranted,
+    screenRecording: screenGranted,
+    processPath: processPath,
+    bundleId: bundleId
+)
+
+let encoder = JSONEncoder()
+encoder.outputFormatting = .sortedKeys
+if let jsonData = try? encoder.encode(status),
+   let jsonString = String(data: jsonData, encoding: .utf8) {
+    print(jsonString)
+} else {
+    fputs("{\"error\": \"Failed to encode status\"}\n", stderr)
+    exit(1)
+}

package/native/Sources/ScreenshotHelper/main.swift

@@ -0,0 +1,219 @@
+/// screenshot-helper - Isolated screen capture subprocess
+/// Runs in separate process to:
+/// 1. Isolate Screen Recording TCC permission
+/// 2. Prevent ReplayKit CPU spin bug (19% idle CPU after capture)
+///
+/// Usage: screenshot-helper <windowId> <outputPath>
+///        screenshot-helper --fullscreen <outputPath>
+///
+/// macOS Tahoe (26.0+) flash-free notes
+/// ────────────────────────────────────
+/// In macOS 26 Tahoe, the system added a "screen captured" white-flash
+/// animation that fires whenever any process calls into the
+/// `screencapture` coordinator daemon — including the deprecated
+/// `CGWindowListCreateImage` path. The flash is a privacy/awareness
+/// feature, not a bug, but it makes silent background captures
+/// (the kind agent tools do dozens of times a session) visually
+/// disruptive.
+///
+/// `ScreenCaptureKit.SCScreenshotManager.captureImage` uses a different
+/// pipeline that Tahoe's flash hook does NOT intercept. On macOS 14+
+/// (Sonoma and later) we prefer that path; on 12-13 (Monterey/Ventura)
+/// we fall back to the legacy CG path which is silent on those OS
+/// versions anyway.
+
+import Foundation
+import CoreGraphics
+import ImageIO
+import UniformTypeIdentifiers
+import AppKit
+#if canImport(ScreenCaptureKit)
+import ScreenCaptureKit
+#endif
+
+// MARK: - macOS 14+ path (ScreenCaptureKit, flash-free on Tahoe)
+
+#if canImport(ScreenCaptureKit)
+@available(macOS 14.0, *)
+func captureFullScreenSCK(outputPath: String) -> Bool {
+    let semaphore = DispatchSemaphore(value: 0)
+    var captured: CGImage? = nil
+    var captureError: Error? = nil
+
+    Task {
+        do {
+            let content = try await SCShareableContent.current
+            guard let display = content.displays.first else {
+                captureError = NSError(domain: "ScreenshotHelper", code: 10, userInfo: [NSLocalizedDescriptionKey: "no displays"])
+                semaphore.signal()
+                return
+            }
+            let filter = SCContentFilter(display: display, excludingApplications: [], exceptingWindows: [])
+            let config = SCStreamConfiguration()
+            // Capture at native resolution. SCK reports display size in
+            // points; multiply by the display's backingScaleFactor so
+            // the resulting PNG matches the pixel dimensions the legacy
+            // CG path produced. Without this, downstream code that
+            // reads .width/.height on a retina capture would see
+            // half-resolution images.
+            let scale = NSScreen.main?.backingScaleFactor ?? 2.0
+            config.width = Int(CGFloat(display.width) * scale)
+            config.height = Int(CGFloat(display.height) * scale)
+            config.scalesToFit = false
+            config.showsCursor = false
+            let image = try await SCScreenshotManager.captureImage(contentFilter: filter, configuration: config)
+            captured = image
+        } catch {
+            captureError = error
+        }
+        semaphore.signal()
+    }
+
+    _ = semaphore.wait(timeout: .now() + 15)
+    if let err = captureError {
+        fputs("error: ScreenCaptureKit failed: \(err.localizedDescription)\n", stderr)
+        return false
+    }
+    guard let image = captured else {
+        fputs("error: ScreenCaptureKit returned no image\n", stderr)
+        return false
+    }
+    return saveImage(image, to: outputPath)
+}
+
+@available(macOS 14.0, *)
+func captureWindowSCK(windowId: CGWindowID, outputPath: String) -> Bool {
+    let semaphore = DispatchSemaphore(value: 0)
+    var captured: CGImage? = nil
+    var captureError: Error? = nil
+
+    Task {
+        do {
+            let content = try await SCShareableContent.current
+            // Find the SCWindow whose windowID matches the caller's CGWindowID.
+            // SCWindow.windowID is the same CGWindowID under the hood, so
+            // direct equality holds.
+            guard let scwindow = content.windows.first(where: { $0.windowID == windowId }) else {
+                captureError = NSError(domain: "ScreenshotHelper", code: 11, userInfo: [NSLocalizedDescriptionKey: "window \(windowId) not in shareable content"])
+                semaphore.signal()
+                return
+            }
+            let filter = SCContentFilter(desktopIndependentWindow: scwindow)
+            let config = SCStreamConfiguration()
+            let scale = NSScreen.main?.backingScaleFactor ?? 2.0
+            // Use the window's frame for sizing — SCK requires explicit
+            // pixel dimensions on the SCStreamConfiguration.
+            config.width = Int(scwindow.frame.width * scale)
+            config.height = Int(scwindow.frame.height * scale)
+            config.scalesToFit = false
+            config.showsCursor = false
+            let image = try await SCScreenshotManager.captureImage(contentFilter: filter, configuration: config)
+            captured = image
+        } catch {
+            captureError = error
+        }
+        semaphore.signal()
+    }
+
+    _ = semaphore.wait(timeout: .now() + 15)
+    if let err = captureError {
+        fputs("error: ScreenCaptureKit window capture failed: \(err.localizedDescription)\n", stderr)
+        return false
+    }
+    guard let image = captured else {
+        fputs("error: ScreenCaptureKit returned no image\n", stderr)
+        return false
+    }
+    return saveImage(image, to: outputPath)
+}
+#endif
+
+// MARK: - macOS 12-13 path (CGWindowListCreateImage, silent on those versions)
+
+func captureWindow(windowId: CGWindowID, outputPath: String) -> Bool {
+#if canImport(ScreenCaptureKit)
+    if #available(macOS 14.0, *) {
+        return captureWindowSCK(windowId: windowId, outputPath: outputPath)
+    }
+#endif
+    guard let image = CGWindowListCreateImage(
+        .null,
+        .optionIncludingWindow,
+        windowId,
+        [.boundsIgnoreFraming, .nominalResolution]
+    ) else {
+        fputs("error: failed to capture window \(windowId)\n", stderr)
+        return false
+    }
+    return saveImage(image, to: outputPath)
+}
+
+func captureFullScreen(outputPath: String) -> Bool {
+#if canImport(ScreenCaptureKit)
+    if #available(macOS 14.0, *) {
+        return captureFullScreenSCK(outputPath: outputPath)
+    }
+#endif
+    guard let image = CGWindowListCreateImage(
+        CGRect.infinite,
+        .optionOnScreenOnly,
+        kCGNullWindowID,
+        [.nominalResolution]
+    ) else {
+        fputs("error: failed to capture screen\n", stderr)
+        return false
+    }
+    return saveImage(image, to: outputPath)
+}
+
+// MARK: - Shared encoding path
+
+func saveImage(_ image: CGImage, to path: String) -> Bool {
+    let url = URL(fileURLWithPath: path)
+    guard let destination = CGImageDestinationCreateWithURL(
+        url as CFURL,
+        UTType.png.identifier as CFString,
+        1,
+        nil
+    ) else {
+        fputs("error: failed to create image destination\n", stderr)
+        return false
+    }
+
+    CGImageDestinationAddImage(destination, image, nil)
+
+    if CGImageDestinationFinalize(destination) {
+        print("{\"success\": true, \"path\": \"\(path)\", \"width\": \(image.width), \"height\": \(image.height)}")
+        return true
+    } else {
+        fputs("error: failed to write image\n", stderr)
+        return false
+    }
+}
+
+// MARK: - Entry
+
+// Check Screen Recording permission first
+if !CGPreflightScreenCaptureAccess() {
+    fputs("{\"error\": \"screen_recording_denied\", \"message\": \"Grant Screen Recording permission in System Settings > Privacy & Security > Screen & System Audio Recording\"}\n", stderr)
+    exit(2)
+}
+
+// Parse arguments
+let args = CommandLine.arguments
+guard args.count >= 3 else {
+    fputs("usage: screenshot-helper <windowId|--fullscreen> <outputPath>\n", stderr)
+    exit(1)
+}
+
+let success: Bool
+if args[1] == "--fullscreen" {
+    success = captureFullScreen(outputPath: args[2])
+} else if let windowId = UInt32(args[1]) {
+    success = captureWindow(windowId: CGWindowID(windowId), outputPath: args[2])
+} else {
+    fputs("error: invalid window ID\n", stderr)
+    exit(1)
+}
+
+exit(success ? 0 : 1)

package/native/build.sh

@@ -0,0 +1,139 @@
+#!/bin/bash
+# Build script for ClawdCursor native helper (macOS only)
+# Usage: ./build.sh [--adhoc]
+#   --adhoc is now the DEFAULT behavior (required for TCC on macOS 26+)
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd "$SCRIPT_DIR"
+
+# Ensure this script is executable (no dependency on caller having set +x)
+if [ ! -x "$0" ]; then
+    chmod +x "$0"
+fi
+
+echo "🔨 Building ClawdCursor native helper..."
+
+# Build all targets in release mode
+if ! swift build -c release; then
+    echo "❌ Swift build failed. Ensure Xcode Command Line Tools are installed:"
+    echo "   xcode-select --install"
+    exit 1
+fi
+
+# Get the build directory
+BUILD_DIR=".build/release"
+
+# Create the .app bundle structure
+APP_DIR="ClawdCursor.app/Contents/MacOS"
+mkdir -p "$APP_DIR"
+
+# These four binaries are ALL required for correct operation
+REQUIRED_BINARIES="ClawdCursorHost clawdcursor-helper screenshot-helper permission-check"
+MISSING=0
+
+for binary in $REQUIRED_BINARIES; do
+    if [ -f "$BUILD_DIR/$binary" ]; then
+        cp "$BUILD_DIR/$binary" "$APP_DIR/"
+        echo "   ✓ Copied $binary"
+    else
+        echo "   ❌ MISSING required binary: $binary"
+        MISSING=1
+    fi
+done
+
+if [ "$MISSING" -eq 1 ]; then
+    echo ""
+    echo "❌ Build incomplete — one or more required binaries are missing."
+    echo "   Check the swift build output above for compilation errors."
+    exit 1
+fi
+
+echo "✅ Built ClawdCursor.app"
+
+# Generate Contents/Info.plist — REQUIRED for a valid .app bundle. Without it
+# codesign fails with "bundle format unrecognized, invalid, or unsuitable"
+# (issue #150). CFBundleExecutable names the main binary inside Contents/MacOS/.
+cat > "ClawdCursor.app/Contents/Info.plist" <<'PLIST'
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleIdentifier</key>
+    <string>com.clawdcursor.helper</string>
+    <key>CFBundleName</key>
+    <string>ClawdCursor</string>
+    <key>CFBundleDisplayName</key>
+    <string>ClawdCursor</string>
+    <key>CFBundleExecutable</key>
+    <string>ClawdCursorHost</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+    <key>CFBundleVersion</key>
+    <string>1.0.0</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0.0</string>
+    <key>LSMinimumSystemVersion</key>
+    <string>13.0</string>
+    <key>LSUIElement</key>
+    <true/>
+    <key>NSAppleEventsUsageDescription</key>
+    <string>ClawdCursor controls other apps to automate desktop tasks you request.</string>
+</dict>
+</plist>
+PLIST
+echo "   ✓ Wrote Contents/Info.plist"
+
+# Code signing (REQUIRED for TCC on macOS 26+ / Tahoe)
+# Without signing, the app won't appear in System Settings privacy panels
+if [[ -n "$CLAWDCURSOR_SIGN_IDENTITY" ]]; then
+    echo "🔐 Signing with Developer ID: $CLAWDCURSOR_SIGN_IDENTITY"
+    codesign --sign "$CLAWDCURSOR_SIGN_IDENTITY" \
+        --options runtime \
+        --entitlements entitlements.plist \
+        --force \
+        --deep \
+        "ClawdCursor.app"
+    echo "✅ Signed with Developer ID"
+else
+    # Ad-hoc sign by default — CRITICAL for TCC to recognize the app.
+    # NOTE: do NOT use --options runtime (hardened runtime) on the ad-hoc build.
+    # It makes macOS evaluate the helper's Screen-Recording TCC by its OWN
+    # identity (com.clawdcursor.helper) instead of letting it inherit the
+    # daemon host's grant — so a daemon-spawned screenshot-helper is denied and
+    # silently falls back to nut-js (#149). Hardened runtime is only needed on
+    # the Developer-ID/notarized branch above.
+    echo "🔐 Ad-hoc signing (required for TCC permissions)..."
+    if [ -f "entitlements.plist" ]; then
+        codesign --sign - \
+            --entitlements entitlements.plist \
+            --force \
+            --deep \
+            "ClawdCursor.app"
+    else
+        codesign --sign - \
+            --force \
+            --deep \
+            "ClawdCursor.app"
+    fi
+    echo "✅ Ad-hoc signed"
+fi
+
+# Verify signature
+if codesign -v "ClawdCursor.app" 2>/dev/null; then
+    echo "✅ Signature verified"
+else
+    echo "⚠️  Signature verification failed — TCC permissions may not work"
+    echo "   On macOS 26+ (Tahoe), unsigned binaries don't appear in privacy settings"
+fi
+
+echo ""
+echo "📦 Output: $SCRIPT_DIR/ClawdCursor.app"
+echo ""
+echo "To test permissions:"
+echo "  ./ClawdCursor.app/Contents/MacOS/permission-check"
+echo ""
+echo "To launch:"
+echo "  open ClawdCursor.app"

package/native/entitlements.plist

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>com.apple.security.automation.apple-events</key>
+    <true/>
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <false/>
+    <key>com.apple.security.cs.disable-library-validation</key>
+    <false/>
+</dict>
+</plist>