@remcp/runtime 0.2.111 → 0.2.112

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.2.112 — 2026-09-25
+
+- Linux EIS absolute pointer motion converts desktop-wide coordinates into the selected libei region before dispatch and keeps the current pointer device when it remains valid, eliminating accepted-but-undelivered absolute moves.
+- Wayland portal drag-and-drop uses one region-safe target transition while pressed, then reasserts the final target before release so `pointerdown → pointermove → pointerup` remains intact.
+- The live computer-use smoke is serialized per user to prevent concurrent desktop-input races; the final ASUS GNOME Wayland run passed 82/82 checks. Runtime tool names and schemas are unchanged.
+
 ## 0.2.111 — 2026-09-25
 
 - `read_document` reads `.xlsx` files again while `allowedRoots` confinement is enabled: the reader no longer re-enters its own temp staging path through the allowlist.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/runtime",
-  "version": "0.2.111",
+  "version": "0.2.112",
   "description": "First-party ReMCP local device runtime: filesystem, terminal, computer-use, browser, diagnostics and document tools over MCP.",
   "type": "module",
   "license": "MIT",

package/src/extended/desktop-linux.mjs

@@ -1270,22 +1270,16 @@ export async function dragDrop(args = {}) {
     await portalPointerButton(button, true, portalOptions);
     await new Promise(resolve => setTimeout(resolve, clamp(args.hold_ms, 120, 60, 5000)));
 
-    // A single absolute jump while the button is held can be coalesced by Mutter/
-    // XWayland and never become a target-visible pointermove. Send a short,
-    // human-like path so drag-aware toolkits observe movement before button-up.
-    const distance = Math.hypot(toX - fromX, toY - fromY);
-    const steps = Math.max(4, Math.min(20, Math.ceil(distance / 24)));
-    const durationMs = clamp(args.duration_ms, 160, 80, 5000);
-    const stepDelay = Math.max(8, Math.round(durationMs / steps));
-    for (let step = 1; step <= steps; step += 1) {
-      const ratio = step / steps;
-      await portalMoveTo(
-        fromX + (toX - fromX) * ratio,
-        fromY + (toY - fromY) * ratio,
-        portalOptions,
-      );
-      await new Promise(resolve => setTimeout(resolve, stepDelay));
-    }
+    // Keep the pressed pointer on a single absolute-motion transition. Repeated
+    // absolute moves can cross EIS region/device contexts and lose the logical
+    // pressed state. The EIS helper converts the desktop target into region-local
+    // coordinates, so one target move is sufficient and preserves buttons=1.
+    await portalMoveTo(toX, toY, portalOptions);
+    await new Promise(resolve => setTimeout(resolve, clamp(args.duration_ms, 160, 80, 5000)));
+    // Reassert the final target immediately before release. On Mutter/XWayland this
+    // mirrors a real pointer-up gesture and ensures the release is delivered as a
+    // pointerup/mouseup at the dragged target instead of only clearing button state.
+    await portalMoveTo(toX, toY, portalOptions);
     await new Promise(resolve => setTimeout(resolve, 40));
     await portalPointerButton(button, false, portalOptions);
     await new Promise(resolve => setTimeout(resolve, 80));

package/src/helpers/wayland-eis-helper.py

@@ -216,6 +216,8 @@ class EiSender:
         self.lib.ei_device_has_capability.restype = ctypes.c_bool
         self.lib.ei_device_get_region_at.argtypes = [c_void_p, ctypes.c_double, ctypes.c_double]
         self.lib.ei_device_get_region_at.restype = c_void_p
+        self.lib.ei_region_convert_point.argtypes = [c_void_p, ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double)]
+        self.lib.ei_region_convert_point.restype = ctypes.c_bool
         self.lib.ei_device_start_emulating.argtypes = [c_void_p, ctypes.c_uint32]
         self.lib.ei_device_stop_emulating.argtypes = [c_void_p]
         self.lib.ei_device_keyboard_key.argtypes = [c_void_p, ctypes.c_uint32, ctypes.c_bool]
@@ -367,17 +369,46 @@ class EiSender:
                 return state["ptr"]
         raise RuntimeError(f"no resumed EIS device with capability {cap}")
 
+    def _absolute_motion_for_device(self, device, x, y):
+        if not self.lib.ei_device_has_capability(device, EI_CAP_POINTER_ABSOLUTE):
+            return None
+        region = self.lib.ei_device_get_region_at(device, float(x), float(y))
+        if not region:
+            return None
+        motion_x = ctypes.c_double(float(x))
+        motion_y = ctypes.c_double(float(y))
+        if not self.lib.ei_region_convert_point(region, ctypes.byref(motion_x), ctypes.byref(motion_y)):
+            raise RuntimeError(f"failed to convert desktop coordinate ({x}, {y}) into the selected EIS region")
+        return motion_x.value, motion_y.value
+
     def device_for_absolute(self, x, y):
         candidates = []
+
+        # Preserve pointer identity across absolute motion whenever the current
+        # device still covers the destination. This is required for pointer
+        # capture during drags: switching EIS devices mid-gesture can drop the
+        # captured pointer before its button release is observed.
+        preferred = self.devices.get(self.pointer_device_key)
+        if preferred and preferred["resumed"] and preferred["emulating"]:
+            device = preferred["ptr"]
+            if self.lib.ei_device_has_capability(device, EI_CAP_POINTER_ABSOLUTE):
+                candidates.append(device)
+                converted = self._absolute_motion_for_device(device, x, y)
+                if converted is not None:
+                    return device, converted[0], converted[1]
+
         for state in self.devices.values():
             if not state["resumed"] or not state["emulating"]:
                 continue
             device = state["ptr"]
+            if preferred and self._device_key(device) == self.pointer_device_key:
+                continue
             if not self.lib.ei_device_has_capability(device, EI_CAP_POINTER_ABSOLUTE):
                 continue
             candidates.append(device)
-            if self.lib.ei_device_get_region_at(device, float(x), float(y)):
-                return device
+            converted = self._absolute_motion_for_device(device, x, y)
+            if converted is not None:
+                return device, converted[0], converted[1]
         if candidates:
             raise RuntimeError(f"no absolute-pointer EIS region contains desktop coordinate ({x}, {y})")
         raise RuntimeError("no resumed EIS device with absolute-pointer capability")
@@ -424,8 +455,8 @@ class EiSender:
         elif op == "motion_absolute":
             x = float(payload["x"])
             y = float(payload["y"])
-            device = self.device_for_absolute(x, y)
-            self.lib.ei_device_pointer_motion_absolute(device, x, y)
+            device, motion_x, motion_y = self.device_for_absolute(x, y)
+            self.lib.ei_device_pointer_motion_absolute(device, motion_x, motion_y)
             self.remember_pointer(device, (x, y))
             self.frame(device)
         elif op == "button":