fix(linux): follow the physical mouse when selecting the active monitor on Hyprland (#1447)

Author: y3owk1n

docs/CROSS_PLATFORM.md

@@ -130,7 +130,7 @@ or no-op) · ❌ no code path
 | **Focused app identity**      | ✅ NSWorkspace + AX      | ✅ `_NET_ACTIVE_WINDOW` / `WM_CLASS` | ⚠️ app_id only (see below) | ⚠️ app_id only     | ✅ `GetForegroundWindow`     |
 | **App watcher (focus change)**| ✅ NSWorkspace observer  | ✅ event-driven        | ✅ event-driven              | ✅ event-driven         | 🟡                           |
 | **Keymap learns the focused app** | ✅ published by the watcher | ✅ published by the watcher | ✅ published by the watcher | ✅ published by the watcher | ⚠️ asked when the keymap settles ¹ |
-| **Cursor position**           | ✅ `CGEventGetLocation`  | ✅ `XQueryPointer`     | ✅ sync-surface trick        | ✅ sync-surface trick   | ✅ `GetCursorPos`            |
+| **Cursor position**           | ✅ `CGEventGetLocation`  | ✅ `XQueryPointer`     | ✅ compositor IPC (Hyprland) / sync-surface trick | ✅ sync-surface trick | ✅ `GetCursorPos` |
 | **Cursor move**               | ✅ `CGEventPost` ([`postMouseMoveLocked`](../internal/adapter/platform/darwin/accessibility_mouse_darwin.m)) | ✅ XTest (`XTestFakeMotionEvent`) | ✅ `zwlr_virtual_pointer` | ✅ libei                | ✅ `SetCursorPos`            |
 | **Mouse buttons / drag**      | ✅ `CGEventPost`         | ✅ XTest               | ✅ `zwlr_virtual_pointer`    | ✅ libei                | ✅ `SendInput`               |
 | **Scroll injection**          | ✅ both axes             | ✅ both axes           | ✅ both axes (uinput + virtual pointer) | ✅ libei     | ⚠️ vertical only             |

internal/adapter/platform/linux/system_common.go

@@ -463,7 +463,7 @@ func (s *SystemAdapter) SyncCursorPosition(ctx context.Context) error {
 	}
 
 	if s.waylandUsesWlrClientStack() {
-		return waylandRefreshCursorPosition()
+		return waylandRefreshCursorPosition(ctx)
 	}
 
 	return nil

internal/adapter/platform/linux/system_cursor_ipc.go

@@ -0,0 +1,55 @@
+//go:build linux
+
+package linux
+
+import (
+	"context"
+	"image"
+	"os"
+)
+
+// Wayland compositor-IPC cursor position. A Wayland client cannot query the
+// global pointer position, so the wlroots client keeps a cache that a plain
+// user-driven mouse move invalidates (wlroots_client.c). The layer-shell
+// discovery refresh corrects it, but depends on the compositor delivering a
+// wl_pointer.enter to a freshly mapped surface within its budget — which
+// Hyprland does not reliably do (#1279). Hyprland exposes the authoritative
+// position over its CLI instead, so the sync path asks it first and keeps
+// discovery as the fallback for the compositors that expose no such query
+// (Sway and niri today).
+
+// waylandCompositorCursorPosition returns the physical cursor position from
+// the running compositor's IPC, when it exposes one. ok=false means "no such
+// query here" — the caller falls back to layer-shell discovery, so a stale
+// HYPRLAND_INSTANCE_SIGNATURE in a non-Hyprland session degrades to the
+// pre-IPC behavior (hyprctl fails to connect and reports nothing).
+//
+// Reached only behind waylandUsesWlrClientStack, which tests the backend the
+// adapter was built with; the socket variable picks the CLI, never the backend
+// (internal/adapter/platform/AGENTS.md).
+func waylandCompositorCursorPosition(ctx context.Context) (image.Point, bool) {
+	if os.Getenv("HYPRLAND_INSTANCE_SIGNATURE") == "" {
+		return image.Point{}, false
+	}
+
+	return hyprlandCursorPosition(ctx)
+}
+
+// hyprlandCursorPosition reads `hyprctl -j cursorpos`, whose x/y are global
+// layout (logical) pixels. That is the space the screen list already lives in:
+// the wlroots client fills each screen's origin and size from
+// zxdg_output_v1.logical_position/logical_size (neru_xdg_output_listener,
+// wlroots_client.c), so on a scaled monitor both sides shrink together and
+// containment checks against screen bounds stay consistent — the same
+// agreement hyprlandFocusedWindowBounds already relies on for `activewindow`.
+func hyprlandCursorPosition(ctx context.Context) (image.Point, bool) {
+	var pos struct {
+		X int `json:"x"`
+		Y int `json:"y"`
+	}
+	if !compositorJSONContext(ctx, &pos, "hyprctl", "-j", "cursorpos") {
+		return image.Point{}, false
+	}
+
+	return image.Point{X: pos.X, Y: pos.Y}, true
+}

internal/adapter/platform/linux/system_focused_window.go

@@ -22,6 +22,11 @@ import (
 // focusedWindowQueryTimeout bounds each compositor IPC call.
 const focusedWindowQueryTimeout = 500 * time.Millisecond
 
+// compositorCLIPipeGuard bounds how long Output may keep waiting on the CLI's
+// stdout pipe after the context kills the process — a CLI that leaked a child
+// inheriting stdout would otherwise hold the pipe open indefinitely.
+const compositorCLIPipeGuard = time.Second
+
 // coordPair is the length of an [x,y] / [w,h] JSON array.
 const coordPair = 2
 
@@ -47,7 +52,19 @@ func compositorJSON(dst any, name string, args ...string) bool {
 	ctx, cancel := context.WithTimeout(context.Background(), focusedWindowQueryTimeout)
 	defer cancel()
 
-	out, err := exec.CommandContext(ctx, name, args...).Output()
+	return compositorJSONContext(ctx, dst, name, args...)
+}
+
+// compositorJSONContext is compositorJSON bounded by the caller's context, for
+// call sites that already carry a deadline (the pre-activation cursor sync).
+// The deadline is real: CommandContext kills the CLI when it expires, and the
+// pipe guard keeps Output from waiting past the kill — this can run under the
+// mode handler's lock, where an unbounded wait stops the keyboard.
+func compositorJSONContext(ctx context.Context, dst any, name string, args ...string) bool {
+	cmd := exec.CommandContext(ctx, name, args...)
+	cmd.WaitDelay = compositorCLIPipeGuard
+
+	out, err := cmd.Output()
 	if err != nil {
 		return false
 	}

internal/adapter/platform/linux/system_wayland_input.go

@@ -3,6 +3,7 @@
 package linux
 
 import (
+	"context"
 	"image"
 	"os"
 	"time"
@@ -138,7 +139,23 @@ func waylandCursorPosition() (image.Point, error) {
 	return wlrootsCursorPosition()
 }
 
-func waylandRefreshCursorPosition() error {
+// waylandRefreshCursorPosition re-learns the physical cursor position after
+// user-driven mouse movement the daemon cannot observe. The compositor's own
+// IPC is authoritative and cheap where it exists (Hyprland), so it is asked
+// first and mirrored into the wlroots cache; the layer-shell discovery pass
+// stays as the fallback for compositors without such a query (#1279).
+func waylandRefreshCursorPosition(ctx context.Context) error {
+	if point, ok := waylandCompositorCursorPosition(ctx); ok {
+		return wlrootsSetCursor(point)
+	}
+
+	// An IPC attempt that burned the whole deadline must not buy the discovery
+	// pass a second budget: this can run under the mode handler's lock, and the
+	// discovery wait is bounded internally, not by this context.
+	if ctx.Err() != nil {
+		return ctx.Err()
+	}
+
 	return wlrootsRefreshCursorPosition()
 }